home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / gtlayout-source.lha / gtlayout.doc < prev    next >
Text File  |  1995-09-24  |  138KB  |  3,791 lines
  1. TABLE OF CONTENTS
  2.  
  3. gtlayout.library/--version--
  4. gtlayout.library/--background--
  5. gtlayout.library/LT_Activate
  6. gtlayout.library/LT_BeginRefresh
  7. gtlayout.library/LT_BuildA
  8. gtlayout.library/LT_CreateHandleTagList
  9. gtlayout.library/LT_DeleteHandle
  10. gtlayout.library/LT_DeleteWindowLock
  11. gtlayout.library/LT_DisposeMenu
  12. gtlayout.library/LT_EndGroup
  13. gtlayout.library/LT_EndRefresh
  14. gtlayout.library/LT_Exit
  15. gtlayout.library/LT_FindMenuCommand
  16. gtlayout.library/LT_Fixed2String
  17. gtlayout.library/LT_FixedMult
  18. gtlayout.library/LT_GetAttributesA
  19. gtlayout.library/LT_GetCode
  20. gtlayout.library/LT_GetIMsg
  21. gtlayout.library/LT_GetMenuItem
  22. gtlayout.library/LT_HandleInput
  23. gtlayout.library/LT_Init
  24. gtlayout.library/LT_LabelChars
  25. gtlayout.library/LT_LabelWidth
  26. gtlayout.library/LT_LayoutMenusA
  27. gtlayout.library/LT_LevelWidth
  28. gtlayout.library/LT_LockWindow
  29. gtlayout.library/LT_MenuControlTagList
  30. gtlayout.library/LT_NewA
  31. gtlayout.library/LT_NewLevelWidth
  32. gtlayout.library/LT_NewMenuTemplate
  33. gtlayout.library/LT_NewMenuTagList
  34. gtlayout.library/LT_PressButton
  35. gtlayout.library/LT_RebuildTagList
  36. gtlayout.library/LT_ReplyIMsg
  37. gtlayout.library/LT_SetAttributesA
  38. gtlayout.library/LT_ShowWindow
  39. gtlayout.library/LT_String2Fixed
  40. gtlayout.library/LT_UnlockWindow
  41. gtlayout.library/LT_UpdateStrings
  42. gtlayout.library/--version--                       gtlayout.library/--version--
  43.  
  44. This document describes gtlayout.library v5.12 or higher. Do not assume that
  45. previous library releases support the same features.
  46. gtlayout.library/--background--                 gtlayout.library/--background--
  47.  
  48.     1. General information
  49.  
  50.     1.1 Purpose
  51.  
  52.     The GUI code included in this archive helps to create user interfaces
  53.     using gadtools.library with a minimum of effort. The code
  54.     automatically takes care of the font to be used, making the user
  55.     interface font independent. Localizing support is built right into
  56.     the code, just install a callback hook and pass numeric IDs for the
  57.     gadget labels: the code will invoke your hook in order to get the
  58.     text required. Keystroke activation of gadgets is also taken care
  59.     of, in fact the code will -- unless told not to do so -- assign keyboard
  60.     shortcuts to the gadgets created all on its own. Every effort has been
  61.     made to make the code reentrant, so it can be put into a shared library.
  62.     If a user interface does not fit onto a screen provisions are made to
  63.     choose a smaller font and to rescale the window contents until they fit.
  64.     Last but not least the user interface code offers transparent extensions
  65.     to the standard gadtools.library objects, such as LISTVIEW_KIND objects
  66.     which respond to double-clicks or STRING_KIND objects which can be used
  67.     to enter password text as they will not display the characters entered.
  68.  
  69.  
  70.     1.2 Distribution
  71.  
  72.     The code is *free*, you don't need to pay any money to use it, nor
  73.     do you need to quote my name in the documentation, the program or
  74.     anywhere else. You are allowed to make changes to the code, but if
  75.     you stumble across any bugs or even know how to fix them, please
  76.     let me know. It does not matter whether you intend to sell a program
  77.     to use the code, use the code in shareware, gift-ware, freeware or
  78.     etc.-ware programs: the code still remains royalty-free.
  79.  
  80.  
  81.     1.3 Caveats
  82.  
  83.     The code is pretty large, about 40K-60K bytes in size. Not all
  84.     gadtools.library type objects are supported, notably
  85.     GENERIC_KIND objects. The code is not as flexible as
  86.     gadtools.library, so certain things which are easily done using
  87.     gadtools.library may be pretty difficult or even impossible.
  88.     The code is written entirely in `C' and requires SAS/C to
  89.     compile. Some parts of the code are highly recursive; I haven't
  90.     measured how many stack they might require in certain cases,
  91.     but I recommend that you don't use the grouping feature too
  92.     much. The data structures required to create and maintain the
  93.     user interface are huge, a single window might require more
  94.     than 4K-6K of memory. Proportional font support only works
  95.     well starting with Kickstart v39 and up, v2.04 will probably
  96.     not look quite that pretty.
  97.  
  98.  
  99.     2. Programming
  100.  
  101.     2.1 Client libraries required
  102.  
  103.     You need to have SysBase and GadToolsBase initialized in order to make
  104.     use of the code, i.e. your code has to do
  105.     WaitPort()...GT_GetIMsg()...GT_ReplyIMsg all on its own. The code makes
  106.     use of the memory pools introduced in exec.library v39, but calls the
  107.     equivalent routines in amiga.lib. Note: as of this writing the pools
  108.     code in amiga.lib v40.14 is broken, so you need to link with Mike
  109.     Sinz' fixed pools.lib.
  110.  
  111.  
  112.     2.2 Invocation procedure
  113.  
  114.     The typical invocation procedure looks roughly like this:
  115.  
  116.        LT_Init();
  117.        :
  118.        :
  119.           LT_CreateHandleTags();
  120.              LT_New();
  121.              :
  122.              :
  123.              LT_New();
  124.                 LT_Build();
  125.                    LT_HandleInput();
  126.           LT_DeleteHandle();
  127.        :
  128.        :
  129.        LT_Exit();
  130.  
  131.     You need to call LT_Init() only once in your program, it will initialize
  132.     the libraries and global data structures required by the user interface
  133.     code. When you are finished with the user interface and your program is
  134.     about to exit you need to call LT_Exit() or memory will get lost.
  135.     Note that LT_Init() is not protected against multiple invocations. If
  136.     called repeatedly memory will get lost which can never be reclaimed.
  137.     However, LT_Exit() is protected against multiple invocations, you can
  138.     also call it before ever giving LT_Init() a call, but I doubt this
  139.     would make much sense. If you are using the shared gtlayout.library
  140.     no call to LT_Init()/LT_Exit() is necessary as these calls are already
  141.     wrapped into the library opening code.
  142.        Before you can actually start building a window layout a call to
  143.     LT_CreateHandleTags() needs to be made. You need to pass in a pointer
  144.     to the Screen your user interface window is to be opened on and,
  145.     optionally, a few tags to control the look and performance of the
  146.     interface. *Never* close the screen in question before calling
  147.     LT_DeleteHandle() or nasty things will happen. For public screens
  148.     the code will try to lock the screen in question. With the handle
  149.     LT_CreateHandleTags() returned you can call LT_New() to build the
  150.     user interface. When finished a call to LT_Build() will finally
  151.     open a window and place the gadgets inside. A pointer to the
  152.     Window created will be returned, ready to be used for the
  153.     WaitPort()...GT_GetIMsg()...LT_HandleInput()...GT_ReplyIMsg()
  154.     loop. When finished, a call to LT_DeleteHandle() will close the
  155.     window and release all the memory associated with it. The design
  156.     of the interface code is similar to the corresponding calls in
  157.     gadtools.library, i.e. you don't need to worry about LT_New()
  158.     failing to allocate memory for the objects required. When it comes
  159.     to LT_Build() the code will know about any trouble which would
  160.     show up during previous invocations of LT_New(). In essence,
  161.     if LT_Build() returns NULL something is wrong.
  162.  
  163.  
  164.     2.3 Hierarchic grouping
  165.  
  166.     The basic building block of the user interface is a group, either
  167.     a horizontal or a vertical group. Adding gadgets or other objects
  168.     to a horizontal group will place them side by side from left to
  169.     right. A vertical group causes objects to be place from top to
  170.     bottom in one straight line. Groups help to arrange objects
  171.     neatly stacked, centered and properly aligned with other
  172.     members of the group.
  173.  
  174.     MUCHO IMPORTANTE: there is a bug lurking in the code which I never
  175.     had the luck to find and fix. One would expect to create
  176.     user interface structures like this:
  177.  
  178.        <group start>
  179.           <button>
  180.           <list>
  181.           <group start>
  182.              <slider>
  183.              <text>
  184.           <group end>
  185.           <button>
  186.        <group end>
  187.  
  188.     However, it is in fact not possible to mix gadgets and groups.
  189.     Thus, the user interface structure would have to look like this:
  190.  
  191.        <group start>
  192.           <group start>
  193.              <button>
  194.              <list>
  195.           <group end>
  196.           <group start>
  197.              <slider>
  198.              <text>
  199.           <group end>
  200.           <group start>
  201.              <button>
  202.           <group end>
  203.        <group end>
  204.  
  205.     Or in other words: groups only mix with other groups.
  206.  
  207.     You build groups using three different object types. In this
  208.     context `object type' refers to a specific numeric value the
  209.     LT_New() routine knows which will cause it to add another leaf
  210.     to the user interface structure tree. Here is an example:
  211.  
  212.        struct LayoutHandle *Handle;
  213.  
  214.        if(Handle = LT_CreateHandleTags(NULL,
  215.           LAHN_AutoActivate,FALSE,
  216.        TAG_DONE))
  217.        {
  218.           struct Window *Window;
  219.  
  220.           LT_New(Handle,
  221.              LA_Type,      VERTICAL_KIND,  /* A vertical group. */
  222.              LA_LabelText, "Main group",   /* Group title text. */
  223.           TAG_DONE);
  224.           {
  225.              LT_New(Handle,
  226.                 LA_Type,      BUTTON_KIND, /* A plain button. */
  227.                 LA_LabelText, "A button",
  228.                 LA_ID,        11,
  229.              TAG_DONE);
  230.  
  231.              LT_New(Handle,
  232.                 LA_Type,      XBAR_KIND,   /* A separator bar. */
  233.              TAG_DONE);
  234.  
  235.              LT_New(Handle,
  236.                 LA_Type,      BUTTON_KIND, /* A plain button. */
  237.                 LA_LabelText, "Another button",
  238.                 LA_ID,        22,
  239.              TAG_DONE);
  240.  
  241.              LT_New(Handle,
  242.                 LA_Type,      END_KIND,    /* This ends the current group. */
  243.              TAG_DONE);
  244.           }
  245.  
  246.           if(Window = LT_Build(Handle,
  247.             LAWN_Title,     "Window title",
  248.             LAWN_IDCMP,     IDCMP_CLOSEWINDOW,
  249.             WA_CloseGadget, TRUE,
  250.           TAG_DONE))
  251.           {
  252.               struct IntuiMessage *Message;
  253.               ULONG                MsgQualifier,
  254.                                    MsgClass;
  255.               UWORD                MsgCode;
  256.               struct Gadget       *MsgGadget;
  257.               BOOL                 Done = FALSE;
  258.  
  259.               do
  260.               {
  261.                   WaitPort(Window -> UserPort);
  262.  
  263.                   while(Message = GT_GetIMsg(Window -> UserPort))
  264.                   {
  265.                      MsgClass     = Message -> Class;
  266.                      MsgCode      = Message -> Code;
  267.                      MsgQualifier = Message -> Qualifier;
  268.                      MsgGadget    = Message -> IAddress;
  269.  
  270.                      GT_ReplyIMsg(Message);
  271.  
  272.                      LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  273.  
  274.                      switch(MsgClass)
  275.                      {
  276.                         case IDCMP_CLOSEWINDOW:
  277.  
  278.                             Done = TRUE;
  279.                             break;
  280.  
  281.                         case IDCMP_GADGETUP:
  282.  
  283.                             switch(MsgGadget -> GadgetID)
  284.                             {
  285.                                 case 11: printf("First gadget\n");
  286.                                          break;
  287.  
  288.                                 case 22: printf("Second gadget\n");
  289.                                          break;
  290.                             }
  291.  
  292.                             break;
  293.                      }
  294.                   }
  295.               }
  296.               while(!Done);
  297.           }
  298.  
  299.           LT_DeleteHandle(Handle);
  300.        }
  301.  
  302.     The example creates one single group, places a few objects inside,
  303.     calls the layout routine, handles the input and finally cleans
  304.     things up again. This example also shows that you *need* at
  305.     least one group in your tree (to form the root) in order to get
  306.     things to work.
  307.        The input loop requires you to call LT_HandleInput() in order
  308.     to get the user interface code to filter out certain events and
  309.     to update internal information. The data passed in must have
  310.     been processed via the gadtools.library routines. You *must not*
  311.     call LT_HandleInput() before GT_ReplyIMsg() is called since the
  312.     routine may call intuition.library and gadtools.library routines
  313.     which in turn might lead to a system lock-up if the message
  314.     has not been processed yet. The first thing to do after LT_HandleInput()
  315.     has done whatever was necessary to the data you passed in is
  316.     examine the MsgClass variable. The user interface code will
  317.     `fake' certain message events using the variables passed in,
  318.     *do not* use any other data gathered from the original
  319.     IntuiMessage. The MsgClass may include event types you did
  320.     not ask for, i.e. the IDCMP flags of the window opened
  321.     will be set according to the objects you added to the window.
  322.     Also, the IDCMP_IDCMPUPDATE message class will show up for
  323.     certain objects. More on this later in this document.
  324.  
  325.  
  326.     2.4 Setting and getting object attributes
  327.  
  328.     The mechanism to update and query object attributes does not
  329.     exactly match the familiar gadtools.library interface. In
  330.     fact, the routine to change gadget attributes will forward
  331.     the tagitem list passed in to gadtools.library/GT_SetGadgetAttrs().
  332.     On the other hand the routine to query object attributes does
  333.     not work like gadtools.library/GT_GetGadgetAttrs(). The
  334.     user interface code assumes that all objects it can handle and
  335.     create posess certain attributes unique to the type of the
  336.     object in question. For example, the unique attribute of a
  337.     STRING_KIND object would be a pointer to the string it
  338.     `contains'. The unique attribute of a SLIDER_KIND object is
  339.     the current slider position. The LT_GetAttributes() routine
  340.     will return this attribute, but also accept a tagitem list
  341.     to fill in for certain special tag values.
  342.  
  343.  
  344.     2.5 Extra data
  345.  
  346.     Once a LayoutHandle has been created the interface code will
  347.     provide you with a number of information concerning the screen
  348.     the handle has been attached to. This information includes
  349.     the DrawInfo structure of the screen, the VisualInfo data
  350.     and the Screen address. This information is read-only.
  351.  
  352.  
  353.     2.6 Menus
  354.  
  355.     With a LayoutHandle available a routine called LT_LayoutMenuTags()
  356.     will create a standard Intuition menu structure via gadtools.library
  357.     which can be passed to LT_Build(). Note that this
  358.     routine does not modify any data passed in, it does neither
  359.     attach the menu created to the LayoutHandle passed in,
  360.     nor does it change the NewMenu table.
  361.  
  362.  
  363.     2.7 Localization
  364.  
  365.     All object and menu creation routines support localization via
  366.     a Hook callback interface, i.e. you can pass a pointer to an
  367.     initialized Hook structure to LT_CreateHandleTags() which will
  368.     later be used to supply label and list text for objects
  369.     created. The Hook callback routine is called in the following
  370.     fashion:
  371.  
  372.        String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,LONG ID)
  373.          D0                            A0                         A2        A1
  374.  
  375.     Or in other words: a locale string ID is passed in, the routine is supposed
  376.     to look up the string to match this ID and to return it.
  377.  
  378.  
  379.     2.8 Object types to generate IDCMP_IDCMPUPDATE events
  380.  
  381.     Certain objects convey extra information which is merged into the `fake'
  382.     input stream passed to the client calling LT_HandleInput(). These objects
  383.     are:
  384.  
  385.        STRING_KIND
  386.        TEXT_KIND
  387.        PALETTE_KIND
  388.  
  389.           The user pressed the `select' button which belongs
  390.           to this gadget. The MsgGadget pointer indicates the
  391.           STRING_KIND/TEXT_KIND/PALETTE_KIND object the `select'
  392.           button belongs to.
  393.  
  394.        LISTVIEW_KIND
  395.  
  396.           The user double-clicked on an entry. The entry number
  397.           is returned in the MsgCode variable. The MsgGadget
  398.           pointer indicates the LISTVIEW_KIND object the user
  399.           has clicked on.
  400.  
  401.  
  402.     2.9 Keystroke activation
  403.  
  404.     Unless forbidden via the the LA_NoKey tag item the user interface
  405.     code will pick the keyboard shortcuts for all gadgets on its own.
  406.     The currently active global console keymap will be checked at the
  407.     time when LT_Init() is called in order to make sure subsequent
  408.     calls to LT_Build() will use only keys the user can press on
  409.     the keyboard. Double-dead keys are also excluded from the
  410.     table created. This avoids problems with gadget labels such as
  411.     "éééé" which would require the user to hit two keys in a row to
  412.     activate the gadget.
  413.        If the window created happens to feature a close gadget
  414.     pressing the `Esc' key will cause the client to receive
  415.     an IDCMP_CLOSEWINDOW event.
  416.        A single LISTVIEW_KIND object may receive special treatment
  417.     if the LALV_CursorKey tag is used: the user will be able to
  418.     operate the listview using the cursor keys. Note: this
  419.     will also keep the user interface code from choosing a
  420.     special keystroke from the gadget label.
  421.        The user will be able to operate a single BUTTON_KIND
  422.     object using the return key if the LABT_ReturnKey tag is
  423.     used. A recessed frame will be drawn around the button hit
  424.     box to indicate its special status.
  425.        Pressing the Tab key can be bound to operate a cycle or
  426.     mx kind object.
  427.  
  428.     3. Credits
  429.  
  430.     The original design is based upon the user interface layout code used by
  431.     `term' 3.1. I put the first version of the layout routines together back
  432.     in Summer 1993 when I wanted to write the follow-up to `term' v3.4.
  433.  
  434.     Martin Taillefer rewrote large parts of the code, added new routines and
  435.     generally improved the performance of the layout process.
  436.  
  437.     Kai Iske, Christoph Feck, Stefan Becker and Michael Barsoom helped to
  438.     iron out the remaining bugs and piled up bug reports and
  439.     enhancement requests.
  440. gtlayout.library/LT_Activate                      gtlayout.library/LT_Activate
  441.  
  442.    NAME
  443.  
  444.         LT_Activate -- Activate a string type gadget.
  445.  
  446.    SYNOPSIS
  447.  
  448.         LT_Activate(Handle,ID);
  449.                       A0   D0
  450.  
  451.         VOID LT_Activate(LayoutHandle *,LONG);
  452.  
  453.    FUNCTION
  454.  
  455.         The equivalent to intuition.library/ActivateGadget().
  456.  
  457.    INPUTS
  458.  
  459.         Handle - Pointer to LayoutHandle structure.
  460.  
  461.         ID - ID of Gadget to activate.
  462.  
  463.    RESULT
  464.  
  465.         none
  466.    SEE ALSO
  467.  
  468.         intuition.library/ActivateGadget
  469. gtlayout.library/LT_BeginRefresh              gtlayout.library/LT_BeginRefresh
  470.  
  471.    NAME
  472.  
  473.         LT_BeginRefresh -- Optimized window refreshing
  474.  
  475.    SYNOPSIS
  476.  
  477.         LT_BeginRefresh(Handle)
  478.                           A0
  479.  
  480.         VOID LT_BeginRefresh(LayoutHandle *);
  481.  
  482.    FUNCTION
  483.  
  484.         If you wish to handle window refreshing all on your own, you
  485.         might want to use the LT_BeginRefresh...LT_EndRefresh pair
  486.         in your program. By default the user interface layout engine
  487.         will automatically intercept IDCMP_REFRESHWINDOW events and
  488.         react to them accordingly.
  489.  
  490.    INPUTS
  491.  
  492.         Handle - Pointer to a LayoutHandle structure.
  493.  
  494.    RESULT
  495.  
  496.         none.
  497.  
  498.    SEE ALSO
  499.  
  500.         intuition.library/BeginRefresh
  501.         intuition.library/EndRefresh
  502.         gtlayout.library/LT_EndRefresh
  503. gtlayout.library/LT_BuildA                          gtlayout.library/LT_BuildA
  504.  
  505.    NAME
  506.  
  507.         LT_BuildA -- turn the user interface specs into a window
  508.                      and gadgets.
  509.  
  510.    SYNOPSIS
  511.  
  512.         Window = LT_BuildA(Handle,Tags);
  513.           D0                 A0    A1
  514.  
  515.         struct Window *LT_BuildA(LayoutHandle *,struct TagItem *);
  516.  
  517.         Window = LT_Build(Handle,...);
  518.  
  519.         struct Window *LT_Build(LayoutHandle *,...);
  520.  
  521.    FUNCTION
  522.  
  523.         This is the big one. After building up a user interface specification
  524.         using LT_NewA() a call to LT_BuildA() will finally lay out the single
  525.         user interface elements, open a window and put the gadgets, etc.
  526.         inside.
  527.  
  528.         The code tries to fit all the gadgets into the window, but if it
  529.         runs out of space it will fall back to a different font and
  530.         rescale the user interface objects to match it. It will first
  531.         fall back onto the system default font. If unsuccessful it will
  532.         as a last resort try to use topaz.font/8.
  533.  
  534.         To make it easier to distinguish between different handles that
  535.         share the same Window->UserPort, the Window->UserData pointer
  536.         will point to the LayoutHandle that created it (V13).
  537.  
  538.         NOTE: Earlier library releases did not support this feature,
  539.               so be prepared to deal with Window->UserData == NULL.
  540.  
  541.    INPUTS
  542.  
  543.         Handle - Pointer to a LayoutHandle structure.
  544.  
  545.         Tags - Pointer to TagItem list controlling window
  546.                and layout attributes.
  547.  
  548.    TAGS
  549.  
  550.         All the tag values given are passed straight away to OpenWindowTags(),
  551.         see intuition.doc for more information.
  552.  
  553.         In addition to this a number of private tag values are supported:
  554.  
  555.         LAWN_Menu (struct Menu *) - The menu to attach to the window, the
  556.             IDCMP flags will be updated to include IDCMP_MENUPICK if this
  557.             tag is used.
  558.  
  559.         LAWN_MenuTemplate (struct NewMenu *) - A list of filled-in
  560.             NewMenu structures which will get passed straight through
  561.             to LT_NewMenuTemplate(). If a menu could be created, it will
  562.             be attached to the window. LT_DeleteHandle() will then later
  563.             automatically dispose of the menu. Please note that the window
  564.             may fail to open due to the menu layout going wrong. Separate
  565.             calls to LT_NewMenuTemplate() and LT_Build() may be a better
  566.             approach since it is easier to find out which process went
  567.             wrong. You will find a pointer to the menu attached to the
  568.             LayoutHandle in LayoutHandle->Menu. Please note that this
  569.             entry only exists in LayoutHandles created by gtlayout.library
  570.             v13 or higher.
  571.  
  572.             NOTE: This tag effectively overrides LAWN_Menu.
  573.  
  574.             (requires gtlayout.library v13 or higher)
  575.  
  576.         LAWN_MenuTags (struct TagItem *) - A list of TagItems which
  577.             will get passed straight through to LT_NewMenuTagList().
  578.             Even if you don't ask for it, LT_Build() will pass
  579.             "LAMN_Handle,<Handle>" in for you, so any additional tags
  580.             specifying screen, fonts, etc. will be overridden. If a menu
  581.             could be created, it will be attached to the window.
  582.             LT_DeleteHandle() will then later automatically dispose of the
  583.             menu. Please note that the window may fail to open due to the
  584.             menu layout going wrong. Separate calls to LT_NewMenuTagList()
  585.             and LT_Build() may be a better approach since it is easier to
  586.             find out which process went wrong. You will find a pointer to the
  587.             menu attached to the LayoutHandle in LayoutHandle->Menu. Please note
  588.             that this entry only exists in LayoutHandles created by
  589.             gtlayout.library v13 or higher.
  590.  
  591.             NOTE: This tag effectively overrides LAWN_Menu and has
  592.                   precedence over LAWN_MenuTemplate.
  593.  
  594.             (requires gtlayout.library v13 or higher)
  595.  
  596.         LAWN_UserPort (struct MsgPort *) - The MsgPort to use as the
  597.             window user port. The MsgPort will be attached using the
  598.             common ModifyIDCMP() method, closing the window will
  599.             first remove and reply all pending messages at this port.
  600.  
  601.         LAWN_Left (LONG) - The left edge position the window is to use.
  602.             This effectively overrides any horizontal alignment flags.
  603.             NOTE: the code may choose to ignore this value if it finds
  604.                   that the window will not fit onto the screen unless
  605.                   the left edge position is changed.
  606.  
  607.         LAWN_Top (LONG) - The top edge position the window is to use.
  608.             This effectively overrides any vertical alignment flags.
  609.             NOTE: the code may choose to ignore this value if it finds
  610.                   that the window will not fit onto the screen unless
  611.                   the top edge position is changed.
  612.  
  613.         LAWN_Zoom (BOOL) - Adds a zoom gadget to the window. Clicking
  614.             on this gadget will cause the window to shrink/zoom back
  615.             to its original position. This differs from the WA_Zoom
  616.             tag behaviour. When the window zooms back to its original
  617.             position the gadgets are automatically refreshed.
  618.             Default: FALSE
  619.  
  620.         LAWN_MaxPen (LONG) - The maximum rendering pen index your code
  621.             will use. Since you are -- with some restrictions -- allowed
  622.             to render into the window created you may want to avoid
  623.             silly side effects if drawing images or other colourful
  624.             textures which do not share the common user interface colours.
  625.             By default the layout code will change the maximum rendering
  626.             pen number for the window to include only the user interface
  627.             pen colours. This can, but need not disturb your own private
  628.             window rendering.
  629.             Look up graphics.library/SetMaxPen for more information.
  630.             Default: determined by looking up Screen->DrawInfo.dri_Pens
  631.  
  632.         LAWN_BelowMouse (BOOL) - This instructs the layout routine to
  633.             centre the window created -- if possible -- below the
  634.             mouse pointer. This effectively ignores any left edge,
  635.             top edge or alignment settings.
  636.             Default: FALSE
  637.  
  638.         LAWN_MoveToWindow (BOOL) - When the window is finally open the
  639.             user interface code will try to make sure the entire window
  640.             is visible on the screen, this may involve moving the
  641.             currently visible portion of an autoscrolling screen.
  642.             Default: TRUE
  643.  
  644.         LAWN_AutoRefresh (BOOL) - Handle IDCMP_REFRESHWINDOW events
  645.             automatically.
  646.             Default: TRUE
  647.  
  648.         LAWN_HelpHook (struct Hook *) - Hook code to invoke when the user
  649.             presses the "Help" key. See gtlayout.h for more information.
  650.             Default: NULL
  651.  
  652.         LAWN_Parent (struct Window *) - Parent window to centre the child
  653.             window in.
  654.             Default: NULL
  655.  
  656.         LAWN_BlockParent (BOOL) - Lock the parent window via LT_LockWindow()
  657.             until the child window is closed. NOTE: requires LAWN_Parent
  658.             attribute.
  659.             Default: FALSE
  660.  
  661.         LAWN_SmartZoom (BOOL) - Attach a zoom gadget to the window created.
  662.             When in zoomed state, the window will be as small as possible,
  663.             showing only the window title and window gadgets:
  664.             NOTE: this tag implies LAWN_Zoom,TRUE
  665.             Default: FALSE
  666.  
  667.         LAWN_Title (STRPTR) - The window title to use. Use this tag in
  668.             place of WA_Title or you will break the layout code.
  669.             Default: no title
  670.  
  671.         LAWN_Bounds (struct IBox *) - Bounds to centre the window in.
  672.             Default: NULL
  673.  
  674.         LAWN_ExtraWidth (LONG) - Extra width to add into the calculation
  675.             when opening the window.
  676.             Default: 0
  677.  
  678.         LAWN_ExtraHeight (LONG) - Extra height to add into the calculation
  679.             when opening the window.
  680.             Default: 0
  681.  
  682.         LAWN_IDCMP (ULONG) - Use this tag in place of WA_IDCMP or you
  683.             will break the object handling code.
  684.  
  685.         LAWN_AlignWindow (UWORD) - Alignment information for the window, must
  686.             be a mask made from the following bit values:
  687.  
  688.                 ALIGNF_RIGHT - Align to screen right edge
  689.                 ALIGNF_LEFT - Align to screen left edge
  690.                 ALIGNF_TOP - Align to screen top edge
  691.                 ALIGNF_BOTTOM - Align to screen bottom edge
  692.  
  693.             Unless forbidden (such as by passing ALIGNF_RIGHT|ALIGNF_TOP)
  694.             the window will be centered horizontally and/or vertically.
  695.  
  696.         LAWN_FlushLeft (BOOL) - Add no horizontal space surrounding the
  697.             objects the windows will hold.
  698.             (requires gtlayout.library v10 or higher)
  699.  
  700.         LAWN_FlushTop (BOOL) - Add no vertical space surrounding the
  701.             objects the windows will hold.
  702.             (requires gtlayout.library v10 or higher)
  703.  
  704.         LAWN_Show (BOOL) - Make the window visible when it is opened;
  705.             this may involve depth-arranging screens.
  706.             (requires gtlayout.library v10 or higher)
  707.  
  708.    RESULT
  709.  
  710.         Window - Pointer to a Window structure.
  711.  
  712.    SEE ALSO
  713.  
  714.        intuition.library/OpenWindow
  715.        intuition.library/OpenWindowTagList
  716. gtlayout.library/LT_CreateHandleTagList gtlayout.library/LT_CreateHandleTaglist
  717.  
  718.    NAME
  719.  
  720.         LT_CreateHandleTagList -- Allocate auxilary data required by LT_New()
  721.                                   and LT_BuildA().
  722.  
  723.    SYNOPSIS
  724.  
  725.         Handle = LT_CreateHandleTagList(Screen,Tags);
  726.           D0                              A0    A1
  727.  
  728.         LayoutHandle *LT_CreateHandleTagList(struct Screen *,struct TagItem *);
  729.  
  730.         Handle = LT_CreateHandleTags(Screen,...);
  731.  
  732.         struct LayoutHandle *LT_CreateHandleTags(struct Screen *,...);
  733.  
  734.    FUNCTION
  735.  
  736.         Memory is allocated, tables are set up and data is collected
  737.         on a screen a user interface is to be opened on. This
  738.         involves calculating the screen font parameters.
  739.  
  740.    INPUTS
  741.  
  742.         Screen - Pointer to the screen the user interface is to
  743.                  use. Passing NULL will cause the default public
  744.                  screen to be used.
  745.  
  746.                  NOTE: if NULL is passed the default public screen
  747.                        will stay locked until LT_DeleteHandle()
  748.                        is called.
  749.  
  750.         Tags - Tag values to control certain aspects of the
  751.                user interface created.
  752.  
  753.    TAGS
  754.  
  755.         LAHN_AutoActivate (BOOL) - Set to TRUE if you want the interface
  756.             to always keep a string gadget active if possible. Hitting
  757.             the return key will then cause the next following string
  758.             gadget to get activated, either cycling through all the
  759.             string gadgets available or stopping at the next string
  760.             gadget to have the LAST_LastGadget attribute set.
  761.             Default: TRUE
  762.  
  763.         LAHN_RawKeyFilter (BOOL) - Discard unprocessed IDCMP_RAWKEY
  764.             events.
  765.             Default: TRUE
  766.             (requires gtlayout.library v13 or higher)
  767.  
  768.         LAHN_UserData (APTR) - Store user specific data in the
  769.             LayoutHandle->UserData entry.
  770.  
  771.             NOTE: This tag requires gtlayout.library v9 and the
  772.                   corresponding entry in the LayoutHandle exists
  773.                   only under gtlayout.library v9 and up. *NEVER*
  774.                   write to this entry, use LT_SetAttributes()
  775.                   instead.
  776.  
  777.         LAHN_LocaleHook (struct Hook *) - The hook to call when
  778.             locale string IDs are to be mapped to strings. The
  779.             hook function is called with the following parameters:
  780.  
  781.             String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,
  782.               D0                            A0                         A2
  783.                               LONG ID)
  784.                                    A1
  785.  
  786.             The function is to look up the string associated with the ID
  787.             passed in and return the string.
  788.             Default: no locale hook
  789.  
  790.         LAHN_Font (struct TTextAttr *) - The text font to use when creating
  791.             the gadgets and objects.
  792.             Default: Screen->Font
  793.  
  794.         LAHN_CloningPermitted (BOOL) - If a window will not fit onto the
  795.             screen the user interface is intended for, the layout engine
  796.             will scale the interface data down while stepping down in
  797.             font size. If all this fails, the engine will open a custom
  798.             screen for the window; this process is called "cloning".
  799.             The LAHN_CloningPermitted tag controls whether the engine will
  800.             actually try to open the custom screen or just return NULL
  801.             when LT_Build fails.
  802.             Default: TRUE
  803.  
  804.         LAHN_EditHook (struct Hook *) - You can specify a default string
  805.             gadget editing hook to be used for all following string
  806.             gadgets. Your hook should obey the same rules that apply
  807.             to hooks passed via GTST_EditHook/GTIN_EditHook.
  808.             Default: NULL
  809.  
  810.         LAHN_ExactClone (BOOL) - This tag works in conjunction with the
  811.             LAHN_CloningPermitted tag. By default the layout engine will
  812.             try to replicate only the basic characteristics of the
  813.             screen the window was intended to open on. This may result
  814.             in a screen which uses less colours than the original
  815.             screen. You can force the engine to make an almost exact
  816.             clone of the original screen by passing the LAHN_ExactClone
  817.             tag with a value of TRUE.
  818.             Default: FALSE
  819.  
  820.         LAHN_MenuGlyphs (BOOL) - This tag will make the layout engine
  821.             fill in the AmigaGlyph and CheckGlyph entries of the
  822.             LayoutHandle if running under Kickstart 3.0 or higher.
  823.             The corresponding images will be scaled to fit the actual
  824.             screen aspect ratio values and can later be used for
  825.             menu layout.
  826.             Default: FALSE
  827.  
  828.         LAHN_Parent (struct Window *) - You can pass a pointer to the
  829.             parent window of the window you intend to open using
  830.             the user interface layout engine. The new window will
  831.             open inside the boundaries of the parent window. If the
  832.             size does not fit, it will be opened centered over the
  833.             parent window.
  834.             Default: NULL
  835.  
  836.         LAHN_BlockParent (BOOL) - This tag works in conjunction with the
  837.             LAHN_Parent tag. If in effect, will block the parent window
  838.             via LT_LockWindow until the new window is closed, after
  839.             which the parent window is unlocked again.
  840.             Default: FALSE
  841.  
  842.         LAHN_SimpleClone (BOOL) - This tag works in conjunction with the
  843.             LAHN_CloningPermitted tag. It will make the layout engine
  844.             forget most information about the original screen the
  845.             user interface was intended for. In short, it will open a
  846.             simple default screen for the interface.
  847.             Default: FALSE
  848.  
  849.         LAHN_ExitFlush (BOOL) - When the LayoutHandle is finally disposed
  850.             of with LT_DeleteHandle() all variables maintained by the
  851.             input handling code will be flushed. For example, if you
  852.             would use the LA_STRPTR tag for STRING_KIND objects the
  853.             last string gadget contents would be copied into the buffer
  854.             pointed to by LA_STRPTR. If you do not want to use this
  855.             feature, disable it with "LAHN_ExitFlush,FALSE".
  856.             Default: TRUE
  857.  
  858.             (requires gtlayout.library v9 or higher)
  859.  
  860.    RESULT
  861.  
  862.         Handle - Pointer to a LayoutHandle structure.
  863. gtlayout.library/LT_DeleteHandle              gtlayout.library/LT_DeleteHandle
  864.  
  865.    NAME
  866.  
  867.         LT_DeleteHandle -- Release storage space allocated by
  868.                            LT_CreateHandleTagList, closing windows,
  869.                            removing gadgets, etc.
  870.  
  871.    SYNOPSIS
  872.  
  873.         LT_DeleteHandle(Handle);
  874.                           A0
  875.  
  876.         VOID LT_DeleteHandle(LayoutHandle *);
  877.  
  878.    FUNCTION
  879.  
  880.         Windows and gadgets created by LT_CreateHandleTagList()
  881.         are removed, any associated memory is deallocated.
  882.  
  883.    INPUTS
  884.  
  885.         Handle - Pointer to a LayoutHandle structure created
  886.                  by LT_CreateHandleTaglist(). Passing NULL is
  887.                  harmless.
  888.  
  889.    RESULT
  890.  
  891.         none
  892.  
  893.    SEE ALSO
  894.  
  895.         gtlayout.library/CreateHandleTagList
  896. gtlayout.library/LT_DeleteWindowLock      gtlayout.library/LT_DeleteWindowLock
  897.  
  898.    NAME
  899.  
  900.         LT_DeleteWindowLock -- Remove all locks from a window
  901.  
  902.    SYNOPSIS
  903.  
  904.         LT_DeleteWindowLock(Window);
  905.                               A0
  906.  
  907.         VOID LT_DeleteWindowLock(struct Window *);
  908.  
  909.    FUNCTION
  910.  
  911.         Before closing a locked window you should call this routine
  912.         which will remove all outstanding locks from it.
  913.  
  914.    INPUTS
  915.  
  916.         Window - Pointer to window structure.
  917.  
  918.    RESULT
  919.  
  920.         none
  921. gtlayout.library/LT_DisposeMenu              gtlayout.library/LT_DisposeMenu
  922.  
  923.    NAME
  924.  
  925.         LT_DisposeMenu -- Release storage space allocated by
  926.                           LT_NewMenuTemplate or LT_NewMenuTagList (V11)
  927.  
  928.    SYNOPSIS
  929.  
  930.         LT_DisposeMenu(Menu)
  931.                         A0
  932.  
  933.         VOID LT_DisposeMenu(struct Menu *);
  934.  
  935.    FUNCTION
  936.  
  937.         Menus and MenuItems allocated by LT_NewMenuTemplate or
  938.         LT_NewMenuTagList are deallocated.
  939.  
  940.    INPUTS
  941.  
  942.         Menu - Pointer to Menu structure as returned by
  943.                LT_NewMenuTemplate or LT_NewMenuTagList. Passing
  944.                NULL is harmless.
  945.  
  946.    RESULT
  947.  
  948.         none
  949.  
  950.    SEE ALSO
  951.  
  952.         gtlayout.library/LT_NewMenuTagList
  953.         gtlayout.library/LT_NewMenuTemplate
  954. gtlayout.library/LT_EndGroup                      gtlayout.library/LT_EndGroup
  955.  
  956.    NAME
  957.  
  958.         LT_EndGroup -- end a group declaration.
  959.  
  960.    SYNOPSIS
  961.  
  962.         LT_EndGroup(Handle);
  963.                      A0
  964.  
  965.         VOID LT_EndGroup(LayoutHandle *);
  966.  
  967.    FUNCTION
  968.  
  969.        This is just a short form of
  970.  
  971.            LT_New(Handle,
  972.                LA_Type, END_KIND,
  973.            TAG_DONE);
  974.  
  975.        It helps to save (some) space.
  976.  
  977.    INPUTS
  978.  
  979.        Handle - Pointer to LayoutHandle.
  980.  
  981.    RESULT
  982.  
  983.        none
  984. gtlayout.library/LT_EndRefresh                  gtlayout.library/LT_EndRefresh
  985.  
  986.    NAME
  987.  
  988.         LT_EndRefresh -- Optimized window refreshing
  989.  
  990.    SYNOPSIS
  991.  
  992.         LT_EndRefresh(Handle)
  993.                         A0
  994.  
  995.         VOID LT_EndRefresh(LayoutHandle *);
  996.  
  997.    FUNCTION
  998.  
  999.         If you wish to handle window refreshing all on your own, you
  1000.         might want to use the LT_BeginRefresh...LT_EndRefresh pair
  1001.         in your program. By default the user interface layout engine
  1002.         will automatically intercept IDCMP_REFRESHWINDOW events and
  1003.         react to them accordingly.
  1004.  
  1005.    INPUTS
  1006.  
  1007.         Handle - Pointer to a LayoutHandle structure.
  1008.  
  1009.    RESULT
  1010.  
  1011.         none.
  1012.  
  1013.    SEE ALSO
  1014.  
  1015.         intuition.library/BeginRefresh
  1016.         intuition.library/EndRefresh
  1017.         gtlayout.library/LT_BeginRefresh
  1018. gtlayout.library/LT_Exit                              gtlayout.library/LT_Exit
  1019.  
  1020.    NAME
  1021.  
  1022.         LT_Exit -- Clean up user interface allocations
  1023.  
  1024.    SYNOPSIS
  1025.  
  1026.         LT_Exit();
  1027.  
  1028.         VOID LT_Exit(VOID);
  1029.  
  1030.    FUNCTION
  1031.  
  1032.         When you are finished with user interface creation and
  1033.         do not not need the code any more you should call this
  1034.         routine. It will free all the memory allocated by
  1035.         LT_Init(), close libraries, etc.
  1036.  
  1037.    INPUTS
  1038.  
  1039.         none
  1040.  
  1041.    RESULT
  1042.  
  1043.         none
  1044.  
  1045.    NOTES
  1046.  
  1047.         This routine is available in the link library only.
  1048. gtlayout.library/LT_FindMenuCommand          gtlayout.library/LT_FindMenuCommand
  1049.  
  1050.    NAME
  1051.  
  1052.         LT_FindMenuCommand -- Get the menu/submenu item associated
  1053.                               with a rawkey event (V11)
  1054.  
  1055.    SYNOPSIS
  1056.  
  1057.         Item = LT_FindMenuCommand(Menu,Code,Qualifier,Gadget)
  1058.          D0                        A0  D0       D0      A1
  1059.  
  1060.         struct MenuItem *LT_FindMenuCommand(struct Menu *,
  1061.  
  1062.                              UWORD,ULONG,struct Gadget *);
  1063.  
  1064.    FUNCTION
  1065.  
  1066.         With the IntuiMessage data copied from a type IDCMP_RAWKEY message
  1067.         tries to find the MenuItem the event referred to.
  1068.  
  1069.    INPUTS
  1070.  
  1071.         Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1072.  
  1073.         Code - Value copied from IntuiMessage->Code
  1074.  
  1075.         Qualifier - Value copied from IntuiMessage->Qualifier
  1076.  
  1077.         Gadget - Value copied from IntuiMessage->IAddress
  1078.  
  1079.    RESULT
  1080.  
  1081.         Item - Pointer to the struct MenuItem * in question or NULL
  1082.                if none could be found
  1083.  
  1084.    SEE ALSO
  1085.  
  1086.         gtlayout.library/LT_NewMenuTagList
  1087. gtlayout.library/LT_Fixed2String              gtlayout.library/LT_Fixed2String
  1088.  
  1089.    NAME
  1090.  
  1091.         LT_Fixed2String -- Convert a fixed-point number into an alphanumeric
  1092.                            string.
  1093.  
  1094.    SYNOPSIS
  1095.  
  1096.         LT_Fixed2String(Fixed,String);
  1097.                           D0    D1
  1098.  
  1099.         VOID LT_Fixed2String(FIXED,STRPTR);
  1100.  
  1101.    FUNCTION
  1102.  
  1103.         This routine implements a service similar to ftoa(). It converts
  1104.         a fixed point number into an ASCII representation.
  1105.  
  1106.    INPUTS
  1107.  
  1108.         Fixed - Fixed point numeric value
  1109.  
  1110.         String - Buffer to receive the converted value. This buffer
  1111.                  must be at least 12 bytes large.
  1112.  
  1113.    NOTES
  1114.  
  1115.         The decimal point will be taken from the current locale.
  1116.         If locale.library is not installed in your system, the
  1117.         `.' character will be used instead.
  1118.  
  1119.         The arguments are passed in D0 and D1, this is *not* a
  1120.         typo.
  1121.  
  1122.    SEE ALSO
  1123.  
  1124.         gtlayout.library/LT_String2Fixed
  1125. gtlayout.library/LT_FixedMult                    gtlayout.library/LT_FixedMult
  1126.  
  1127.    NAME
  1128.  
  1129.         LT_FixedMult -- Multiply a fixed-point number with an integer value.
  1130.  
  1131.    SYNOPSIS
  1132.  
  1133.         Fixed = LT_FixedMult(Fixed,Factor)
  1134.           D0                   D0    D1
  1135.  
  1136.         FIXED LT_FixedMult(FIXED,ULONG);
  1137.  
  1138.    FUNCTION
  1139.  
  1140.         The layout engine provides only a fixed point multiplication
  1141.         routine. You need to implement other numeric operations on
  1142.         your own.
  1143.  
  1144.    INPUTS
  1145.  
  1146.         Fixed - Fixed-point number to be multiplied.
  1147.  
  1148.         Factor - Integer value to multiply fixed-point number
  1149.                  with.
  1150.  
  1151.    RESULT
  1152.  
  1153.         Fixed - Product
  1154. gtlayout.library/LT_GetAttributesA          gtlayout.library/LT_GetAttributesA
  1155.  
  1156.    NAME
  1157.  
  1158.         LT_GetAttributesA -- Inquire information on a gadget.
  1159.  
  1160.    SYNOPSIS
  1161.  
  1162.         Value = LT_GetAttributesA(Handle,ID,Tags);
  1163.           D0                        A0   D0  A1
  1164.  
  1165.         LONG LT_GetAttributesA(LayoutHandle *,LONG ID,struct TagItem *);
  1166.  
  1167.         Value = LT_GetAttributes(Handle,ID,...);
  1168.  
  1169.         LONG LT_GetAttributes(LayoutHandle *,LONG ID,...);
  1170.  
  1171.    FUNCTION
  1172.  
  1173.         All objects created by the user interface layout code posess
  1174.         certain unique properties. The LT_GetAttributes() function will
  1175.         will inquire this information and return it. The implementation
  1176.         differs from gadtools.library/GT_GetGadgetAttrs in that you
  1177.         can inquire only a small subset of the object properties possible
  1178.         via the taglist passed in.
  1179.  
  1180.    INPUTS
  1181.  
  1182.         Handle - Pointer to LayoutHandle structure.
  1183.  
  1184.         ID - ID number of the object to inquire information about. This
  1185.              is the same value you passed via LA_ID to LT_New() when
  1186.              you created this object.
  1187.  
  1188.         Tags - TagItem list to receive information about the object
  1189.                in question.
  1190.  
  1191.    TAGS
  1192.  
  1193.         LA_Left (LONG *) - Left edge of object.
  1194.  
  1195.         LA_Top (LONG *) - Top edge of object.
  1196.  
  1197.         LA_Width (LONG *) - Width of object.
  1198.  
  1199.         LA_Height (LONG *) - Height of object.
  1200.  
  1201.         LA_Chars (LONG *) - Width of object measured in character
  1202.            widths.
  1203.            (requires gtlayout.library v9 or higher)
  1204.  
  1205.         LA_Lines (LONG *) - Height of object measured in character
  1206.            heights.
  1207.            (requires gtlayout.library v9 or higher)
  1208.  
  1209.         LA_LabelLeft (LONG *) - Left edge of label text.
  1210.            (requires gtlayout.library v9 or higher)
  1211.  
  1212.         LA_LabelTop (LONG *) - Top edge of label text.
  1213.            (requires gtlayout.library v9 or higher)
  1214.  
  1215.         LABO_Object (Object *) - Returns a pointer to the BOOPSI object
  1216.            the BOOPSI_KIND object is based upon.
  1217.  
  1218.            NOTE: Don't unlink the object or dispose of it or terrible
  1219.                  things are bound to happen.
  1220.  
  1221.            (requires gtlayout.library v10 or higher)
  1222.  
  1223.    RESULT
  1224.  
  1225.         The result depends on the object type:
  1226.  
  1227.             VERTICAL_KIND:
  1228.             HORIZONTAL_KIND:
  1229.  
  1230.                 active page
  1231.  
  1232.             FRACTION_KIND:
  1233.  
  1234.                 current LAFC_Number value
  1235.  
  1236.             SCROLLER_KIND:
  1237.  
  1238.                 current GTSC_Top value
  1239.  
  1240.             TAPEDECK_KIND:
  1241.  
  1242.                 current LATD_Pressed value
  1243.  
  1244.             LEVEL_KIND:
  1245.  
  1246.                 current LAVL_Level state
  1247.  
  1248.             CHECKBOX_KIND:
  1249.  
  1250.                 current GTCB_Checked state
  1251.  
  1252.             LISTVIEW_KIND:
  1253.  
  1254.                 current GTLV_Selected state
  1255.  
  1256.             MX_KIND:
  1257.  
  1258.                 current GTMX_Active state
  1259.  
  1260.             CYCLE_KIND:
  1261.  
  1262.                 current GTCY_Active state
  1263.  
  1264.             POPUP_KIND:
  1265.  
  1266.                 current LAPU_Active state
  1267.  
  1268.             TAB_KIND:
  1269.  
  1270.                 current LATB_Active state
  1271.  
  1272.             PALETTE_KIND:
  1273.  
  1274.                 current GTPA_Color state
  1275.  
  1276.             SLIDER_KIND:
  1277.  
  1278.                 current GTSL_Level state
  1279.  
  1280.             GAUGE_KIND:
  1281.  
  1282.                 current LAGA_Percent state
  1283.  
  1284.             STRING_KIND:
  1285.  
  1286.                 pointer to current string
  1287.  
  1288.             PASSWORD_KIND:
  1289.  
  1290.                 pointer to current string
  1291.  
  1292.             INTEGER_KIND:
  1293.  
  1294.                 number currently entered
  1295.  
  1296.             BOOPSI_KIND:
  1297.  
  1298.                 whatever the object thinks is its
  1299.                 current value
  1300. gtlayout.library/LT_GetCode                        gtlayout.library/LT_GetCode
  1301.  
  1302.    NAME
  1303.  
  1304.         LT_GetCode -- Easy raw key event to ANSI conversion.
  1305.  
  1306.    SYNOPSIS
  1307.  
  1308.         Key = LT_GetCode(Qualifier,Class,Code,Gadget);
  1309.          D0                  D0     D1    D2    A0
  1310.  
  1311.         WORD LT_GetCode(ULONG,ULONG,UWORD,struct Gadget *);
  1312.  
  1313.    FUNCTION
  1314.  
  1315.         The user interface layout engine can convert IDCMP_RAWKEY
  1316.         events into ANSI codes. Pass in the data you copied from
  1317.         the IntuiMessage here.
  1318.  
  1319.    INPUTS
  1320.  
  1321.         Qualifier - Copied from IntuiMessage->Qualifier
  1322.  
  1323.         Class - Copied from IntuiMessage->Class
  1324.  
  1325.         Code - Copied from IntuiMessage->Code
  1326.  
  1327.         Gadget - Copied from IntuiMessage->IAddress
  1328.  
  1329.    RESULT
  1330.  
  1331.         Key - ANSI code generated from the input data
  1332.               or -1 if no such code was to be generated.
  1333. gtlayout.library/LT_GetMenuItem          gtlayout.library/LT_GetMenuItem
  1334.  
  1335.    NAME
  1336.  
  1337.         LT_GetMenuItem -- Get the menu/submenu item associated with an ID (V11)
  1338.  
  1339.    SYNOPSIS
  1340.  
  1341.         Item = LT_GetMenuItem(Menu,ID)
  1342.          D0                    A0  D0
  1343.  
  1344.         struct MenuItem *LT_GetMenuItem(struct Menu *,ULONG);
  1345.  
  1346.    FUNCTION
  1347.  
  1348.         This routine scans through all menu items associated with the
  1349.         menu and returns a pointer to the item associated with the
  1350.         given ID value.
  1351.  
  1352.    INPUTS
  1353.  
  1354.         Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1355.  
  1356.         ID - Unique ID of the item to find.
  1357.  
  1358.    RESULT
  1359.  
  1360.         Item - Pointer to the struct MenuItem * in question or NULL
  1361.                if none could be found
  1362.  
  1363.    SEE ALSO
  1364.  
  1365.         gtlayout.library/LT_NewMenuTagList
  1366. gtlayout.library/LT_GetIMsg                        gtlayout.library/LT_GetIMsg
  1367.  
  1368.    NAME
  1369.  
  1370.         LT_GetIMsg -- Retrieve the next pending IntuiMessage
  1371.                       from the window associated with a
  1372.                       LayoutHandle.
  1373.  
  1374.    SYNOPSIS
  1375.  
  1376.         IntuiMessage = LT_GetIMsg(Handle);
  1377.              D0                     A0
  1378.  
  1379.         struct IntuiMessage *LT_GetIMsg(LayoutHandle *);
  1380.  
  1381.    FUNCTION
  1382.  
  1383.         This routine will handle most of the input loop for
  1384.         you. Just pass the pointer to the layout handle in,
  1385.         check if the result code is non-null, copy the data
  1386.         you need and reply the message via LT_ReplyIMsg().
  1387.  
  1388.         You will still need to wait for new input, as LT_GetIMsg
  1389.         will poll the MsgPort of the window.
  1390.  
  1391.         LT_GetIMsg() will try its best to distinguish between
  1392.         different LayoutHandles sharing the same Window->UserPort.
  1393.         If it finds that the window the message was sent to is
  1394.         using a different LayoutHandle, it will switch to using
  1395.         this handle (V13).
  1396.  
  1397.    INPUTS
  1398.  
  1399.         Handle - Pointer to LayoutHandle structure
  1400.  
  1401.    RESULT
  1402.  
  1403.         IntuiMessage - Pointer to IntuiMessage structure
  1404.  
  1405.    NOTES
  1406.  
  1407.         You *must not* make any assumptions about the contents
  1408.         of the IntuiMessage structure except for the following
  1409.         entries:
  1410.  
  1411.            Class
  1412.            Code
  1413.            Qualifier
  1414.            IAddress
  1415.  
  1416.         When finished, you must dispose the IntuiMessage via
  1417.         LT_ReplyIMsg or memory will be lost which can never
  1418.         be reclaimed.
  1419.  
  1420.         DO NOT CALL LT_HandleInput() ON THE DATA YOU RECEIVE
  1421.         FROM LT_GetIMsg() AS LT_GetIMsg() ALREADY DOES ALL THE
  1422.         MAGIC LT_HandleInput() OTHERWISE WOULD NEED TO DO!
  1423.         IF YOU STILL DO CALL LT_HandleInput() ON THE DATA YOU
  1424.         WILL RECEIVE `GHOST' EVENTS.
  1425.  
  1426.    SEE ALSO
  1427.  
  1428.         gtlayout.library/LT_ReplyIMsg
  1429. gtlayout.library/LT_HandleInput                gtlayout.library/LT_HandleInput
  1430.  
  1431.    NAME
  1432.  
  1433.         LT_HandleInput -- Filter IntuiMessage data.
  1434.  
  1435.    SYNOPSIS
  1436.  
  1437.         LT_HandleInput(Handle,Qualifier,Class,Code,Gadget);
  1438.                          A0      A1      A2    A2    A3
  1439.  
  1440.         VOID LT_HandleInput(LayoutHandle *,ULONG,ULONG *,
  1441.                             UWORD *,struct Gadget **);
  1442.  
  1443.    FUNCTION
  1444.  
  1445.         In order to keep track of user interface actions, such as
  1446.         keys getting pressed, sliders getting moved, etc. your
  1447.         code is to call LT_HandleInput() with data copied from the
  1448.         IntuiMessage it has just received and replied.
  1449.  
  1450.         NOTE: do not call this routine before you have actually
  1451.               replied the IntuiMessage received or weird things
  1452.               may happen.
  1453.  
  1454.    INPUTS
  1455.  
  1456.         Handle - Pointer to a LayoutHandle structure.
  1457.  
  1458.         Qualifier - The Qualifier value copied from the
  1459.                     IntuiMessage structure.
  1460.  
  1461.         Class - Pointer to the ULONG variable which holds the
  1462.                 value copied from the Class entry of the
  1463.                 IntuiMessage structure.
  1464.  
  1465.         Code - Pointer to the UWORD variable which holds the
  1466.                value copied from the Code entry of the
  1467.                IntuiMessage structure.
  1468.  
  1469.         Gadget - Pointer to the Gadget value copied from the
  1470.                  IAddress entry of the IntuiMessage structure.
  1471.  
  1472.    WARNING
  1473.  
  1474.         For BOOPSI_KIND objects keystroke activation may lead to
  1475.         unexpected results. Your application will hear a IDCMP_GADGETUP
  1476.         event, the IntuiMessage->Code value will hold the ANSI key
  1477.         code of the key the user pressed.
  1478.  
  1479.    EXAMPLE
  1480.  
  1481.         struct IntuiMessage *IntuiMessage;
  1482.         ULONG Qualifier,Class;
  1483.         UWORD Code;
  1484.         struct Gadget *Gadget;
  1485.  
  1486.         for(;;)
  1487.         {
  1488.             WaitPort(Window -> UserPort);
  1489.  
  1490.             while(IntuiMessage = GT_GetIMsg(Window -> UserPort))
  1491.             {
  1492.                 Class = IntuiMessage -> Class;
  1493.                 Code = IntuiMessage -> Code;
  1494.                 Qualifier = IntuiMessage -> Qualifier;
  1495.                 Gadget = IntuiMessage -> Gadget;
  1496.  
  1497.                 GT_ReplyIMsg(IntuiMessage);
  1498.  
  1499.                 LT_HandleInput(Handle,Qualifier,&Class,&Code,&Gadget);
  1500.             }
  1501.         }
  1502.  
  1503.    RESULT
  1504.  
  1505.         none
  1506. gtlayout.library/LT_Init                              gtlayout.library/LT_Init
  1507.  
  1508.    NAME
  1509.  
  1510.         LT_Init -- Initialize user interface code.
  1511.  
  1512.    SYNOPSIS
  1513.  
  1514.         LT_Init();
  1515.  
  1516.         VOID LT_Init(VOID);
  1517.  
  1518.    FUNCTION
  1519.  
  1520.         You need to initialize the user interface code only once,
  1521.         so it can set up its internals, open libraries, etc.
  1522.         The code has to be initialized before any user interface
  1523.         creation can take place.
  1524.  
  1525.    INPUTS
  1526.  
  1527.         none
  1528.  
  1529.    RESULT
  1530.  
  1531.         none
  1532.  
  1533.    NOTES
  1534.  
  1535.         This routine is available in the link library only.
  1536. gtlayout.library/LT_LabelChars                  gtlayout.library/LT_LabelChars
  1537.  
  1538.    NAME
  1539.  
  1540.         LT_LabelChars -- Calculate the width of a a string
  1541.                          according to the user interface font
  1542.                          associated with a LayoutHandle.
  1543.  
  1544.    SYNOPSIS
  1545.  
  1546.         Length = LT_LabelChars(Handle,Label);
  1547.           D0                     A0    A1
  1548.  
  1549.         LONG LT_LabelChars(struct LayoutHandle *,STRPTR);
  1550.  
  1551.    FUNCTION
  1552.  
  1553.         Calculates the width of a string according to the user
  1554.         interface font used. The width is then converted to a number
  1555.         of characters suitable for using with the LA_Chars tag
  1556.         item when calling LT_New().
  1557.  
  1558.         You can pass multi-line label texts to this routine,
  1559.         it will calculate the maximum length of the single
  1560.         lines. (V12)
  1561.  
  1562.    INPUTS
  1563.  
  1564.         Handle - Pointer to LayoutHandle structure.
  1565.  
  1566.         Label - Pointer to string.
  1567.  
  1568.    RESULT
  1569.  
  1570.         Length - Number of characters that are considered
  1571.             equivalent to the string length in pixels.
  1572. gtlayout.library/LT_LabelWidth                  gtlayout.library/LT_LabelWidth
  1573.  
  1574.    NAME
  1575.  
  1576.         LT_LabelWidth -- Calculate the width of a string according
  1577.                          to the user interface font used.
  1578.  
  1579.    SYNOPSIS
  1580.  
  1581.         Width = LT_LabelWidth(Handle,Label);
  1582.           D0                    A0    A1
  1583.  
  1584.         LONG LT_LabelWidth(LayoutHandle *,STRPTR);
  1585.  
  1586.    FUNCTION
  1587.  
  1588.         This routine calculates the width of strings in
  1589.         terms of pixels according to the user interface
  1590.         font associated with the LayoutHandle.
  1591.  
  1592.         You can pass multi-line label texts to this routine,
  1593.         it will calculate the maximum length of the single
  1594.         lines. (V12)
  1595.  
  1596.    INPUTS
  1597.  
  1598.         Handle - Pointer to LayoutHandle structure.
  1599.  
  1600.    RESULT
  1601.  
  1602.         Width - Width of the text string in pixels.
  1603. gtlayout.library/LT_LayoutMenusA              gtlayout.library/LT_LayoutMenusA
  1604.  
  1605.    NAME
  1606.  
  1607.         LT_LayoutMenusA -- Create a menu according to a template.
  1608.  
  1609.    SYNOPSIS
  1610.  
  1611.         Menu = LT_LayoutMenusA(Handle,Template,Tags);
  1612.          D0                      A0     A1      A2
  1613.  
  1614.         struct Menu *LT_LayoutMenusA(LayoutHandle *,struct NewMenu *,struct TagItem *);
  1615.  
  1616.         Menu = LT_LayoutMenus(Handle,Template,...);
  1617.  
  1618.         struct Menu *LT_LayoutMenus(LayoutHandle *,struct NewMenu *,...);
  1619.  
  1620.    FUNCTION
  1621.  
  1622.         Unlike the corresponding routines in gadtools.library
  1623.         LT_LayoutMenusA() will both create and layout a menu.
  1624.         Also included is locale support.
  1625.  
  1626.    INPUTS
  1627.  
  1628.         Handle - Pointer to LayoutHandle structure.
  1629.  
  1630.         Template - Address of a ready-to-use NewMenu table to
  1631.             create the menu from.
  1632.  
  1633.         Tags - Tagitem list to control menu attributes
  1634.  
  1635.    TAGS
  1636.  
  1637.         LAMN_FirstLabel (LONG) - Locale ID of the first string to
  1638.             use as a menu title/item/subitem label. This tag
  1639.             works in conjunction with LA_LastLabel.
  1640.  
  1641.         LAMN_LastLabel (LONG) - Locale ID of the last string to
  1642.             use as a menu title/item/subitem label. This tag
  1643.             works in conjunction with LA_FirstLabel. The code
  1644.             will loop through FirstLabel..LastLabel and assign
  1645.             the corresponding locale text for each ID to the
  1646.             NewMenu.nm_Label entries. Labels which are already
  1647.             initialized with NM_BARLABEL are skipped.
  1648.  
  1649.         LAMN_LabelTable (LONG *) - Pointer to an array of IDs
  1650.             to use for building the menu labels. This requires
  1651.             that a locale hook is provided with the layout handle.
  1652.             The array is terminated by -1.
  1653.  
  1654.    NOTES
  1655.  
  1656.         If you created the LayoutHandle with the LAHN_MenuGlyphs,TRUE
  1657.         attribute, the menu will use the scaled menu glyphs.
  1658.  
  1659.    RESULT
  1660.  
  1661.         Menu - Pointer to a Menu structure. You can free this
  1662.                using gadtools.library/FreeMenus().
  1663. gtlayout.library/LT_LevelWidth                   gtlayout.library/LT_LevelWidth
  1664.  
  1665.    NAME
  1666.  
  1667.         LT_LevelWidth -- Determine the maximum width of a SLIDER_KIND
  1668.                          level string.
  1669.  
  1670.    SYNOPSIS
  1671.  
  1672.         Index = LT_LevelWidth(Handle,FormatString,DispFunc,Min,Max,MaxWidth,
  1673.           D0                    A0        A1         A2     D0  D1    A3
  1674.  
  1675.                                   MaxLen,FullCheck);
  1676.                                     A5      D2
  1677.  
  1678.         LONG LT_LevelWidth(LayoutHandle *,STRPTR,
  1679.                            LONG (*)(struct Gadget *,WORD),LONG,LONG,LONG *,
  1680.                            LONG *,BOOL);
  1681.  
  1682.    FUNCTION
  1683.  
  1684.         In order to make room for the level text displayed by a
  1685.         SLIDER_KIND object one needs to know how much space the
  1686.         longest level string will occupy. Otherwise, the level
  1687.         text may overwrite the gadget label text or the slider
  1688.         container. This routine will rattle through all possible
  1689.         slider settings (as given via the Min and the Max
  1690.         level values) and determine the longest label string
  1691.         according to the font used.
  1692.  
  1693.    INPUTS
  1694.  
  1695.         Handle - Pointer to a LayoutHandle structure, as returned by
  1696.                  a call to LT_CreateHandleTags().
  1697.  
  1698.         FormatString - The sprintf() style formatting string to be used
  1699.                        to format the slider level settings into text.
  1700.                        This is the same string you would pass in via
  1701.                        the GTSL_LevelFormat tag when creating the
  1702.                        slider object.
  1703.                        Default: "%lD" for systems which have locale.library
  1704.                                 installed, "%ld" otherwise.
  1705.  
  1706.         DispFunc - A pointer to the function to filter the slider level
  1707.                    values. The result of this function will then be
  1708.                    used to format a string into the slider level text.
  1709.                    This is the same parameter you would pass in via
  1710.                    the GTSL_DispFunc tag when creating the slider
  1711.                    object.
  1712.  
  1713.                    NOTE: the routine will be called with a NULL Gadget
  1714.                          parameter, make sure your code will handle
  1715.                          this nicely.
  1716.  
  1717.                    Default: no display function
  1718.  
  1719.         Min - The smallest value the slider can be set to. This is
  1720.               same value you would pass in via GTSL_Min when creating
  1721.               the slider object.
  1722.  
  1723.         Max - The largest value the slider can be set to. This is
  1724.               same value you would pass in via GTSL_Max when creating
  1725.               the slider object.
  1726.  
  1727.         MaxWidth - Pointer to a place to store the width of the
  1728.                    longest level string in pixels. If you pass
  1729.                    in NULL instead of the address of a variable
  1730.                    no harm will be done.
  1731.  
  1732.         MaxLen - Pointer to a place to store the length of the
  1733.                  longest level string in characters. If you pass
  1734.                  in NULL instead of the address of a variable
  1735.                  no harm will be done.
  1736.  
  1737.  
  1738.         FullCheck - TRUE will cause the code to rattle through all
  1739.                     possible slider settings, starting from the
  1740.                     minimum value, ending at the maximum value.
  1741.                     While this may be a good idea for a display
  1742.                     function to map slider levels to text strings
  1743.                     of varying length it might be a problem when
  1744.                     it comes to display a range of numbers from
  1745.                     1 to 40,000: the code will loop through
  1746.                     40,000 iterations trying to find the longest
  1747.                     string.
  1748.  
  1749.                     FALSE will cause the code to calculate the
  1750.                     longest level string based only on the
  1751.                     minimum and the maximum value to check.
  1752.                     While this is certainly a good a idea when
  1753.                     it comes to display a range of numbers from
  1754.                     1 to 40,000 as only two values will be
  1755.                     checked the code may fail to produce
  1756.                     accurate results for sliders using display
  1757.                     functions mapping slider levels to strings.
  1758.  
  1759.     RESULT
  1760.  
  1761.         Index - The slider level which gives the longest
  1762.                 level string.
  1763.  
  1764.     NOTES
  1765.  
  1766.         Some compilers have trouble passing parameters in A5. In such
  1767.         a case it is recommended to use gtlayout.library/LT_NewLevelWidth
  1768.         instead.
  1769.  
  1770.     SEE ALSO
  1771.  
  1772.         gtlayout.library/LT_NewLevelWidth
  1773. gtlayout.library/LT_LockWindow                  gtlayout.library/LT_LockWindow
  1774.  
  1775.    NAME
  1776.  
  1777.         LT_LockWindow -- Block user access to a window.
  1778.  
  1779.    SYNOPSIS
  1780.  
  1781.         LT_LockWindow(Window);
  1782.                         A0
  1783.  
  1784.         VOID LT_LockWindow(struct Window *);
  1785.  
  1786.    FUNCTION
  1787.  
  1788.         The window will get a wait mouse pointer attached and a blank
  1789.         Requester, preventing any user gadgets from getting used. The
  1790.         window minimum and maximum sizes are set to the current window
  1791.         size so the user will be unable to resize the window or click
  1792.         on the zoom gadget.
  1793.         This routine nests, multiple calls to LT_LockWindow() using the
  1794.         same window will increment a usage counter, so exactly the
  1795.         same number of calls to LT_UnlockWindow() will be required to
  1796.         unlock the window.
  1797.  
  1798.    INPUTS
  1799.  
  1800.         Window - Pointer to window structure.
  1801.  
  1802.    RESULT
  1803.  
  1804.         none
  1805.  
  1806.    NOTES
  1807.  
  1808.          Do not close the window you have locked unless all the
  1809.          outstanding locks are freed or memory will be lost which
  1810.          can never be reclaimed.
  1811. gtlayout.library/LT_MenuControlTagList          gtlayout.library/LT_MenuControlTagList
  1812.  
  1813.    NAME
  1814.  
  1815.         LT_MenuControlTagList -- Manipulate menus, menu/submenu items (V11)
  1816.  
  1817.    SYNOPSIS
  1818.  
  1819.         LT_MenuControlTagList(Window,Menu,Tags)
  1820.                                A0   A1     A2
  1821.  
  1822.         VOID LT_MenuControlTagList(struct Window *,struct Menu *,struct TagItem *);
  1823.  
  1824.         VOID LT_MenuControlTags(struct Window *,struct Menu *,...);
  1825.  
  1826.    FUNCTION
  1827.  
  1828.         This routine provides a rather efficient way to set and to clear,
  1829.         to enable and to disable a number of menus, menu/submenu items
  1830.         all at once.
  1831.  
  1832.         In v18 this routine was modified to disconnect a menu strip
  1833.         from a window if it is about to change checkmark states. In
  1834.         earlier releases or if a single menu is attached to several
  1835.         windows it is recommended that you disconnect the menu from
  1836.         the windows it is attached to before you call this routine.
  1837.  
  1838.         As of v18 this routine is smart enough to handle menu
  1839.         mutual exclusion.
  1840.  
  1841.    INPUTS
  1842.  
  1843.         Window - Pointer to Window this menu is attached to. Starting with
  1844.                  gtlayout.library v16 this parameter may be NULL.
  1845.  
  1846.         Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1847.  
  1848.         Tags - Pointer to a list of tagitem values, as found
  1849.                in gtlayout.h
  1850.  
  1851.    TAGS
  1852.  
  1853.         LAMN_ID (ULONG) - Unique ID of menu/menu item/submenu item to
  1854.             manipulate.
  1855.  
  1856.         LAMN_Checked (BOOL) - Set the checkmark state of the
  1857.             menu/submenu item.
  1858.  
  1859.         LAMN_Disabled (BOOL) - Set the availability state of the
  1860.             menu/menu item/submenu item.
  1861.  
  1862.    EXAMPLE
  1863.  
  1864.         The following tagitem list will clear the checkmark and
  1865.         disable the menu item associated with ID 5 and set the
  1866.         checkmark for the item associated with ID 6:
  1867.  
  1868.             LAMN_ID,         5,
  1869.               LAMN_Checked,  FALSE,
  1870.               LAMN_Disabled, TRUE,
  1871.             LAMN_ID,         6,
  1872.               LAMN_Checked,  TRUE,
  1873.             TAG_DONE
  1874.  
  1875.    RESULT
  1876.  
  1877.         none
  1878.  
  1879.    BUGS
  1880.  
  1881.         In library versions up to and including v17.2 this routine
  1882.         is broken. It won't do any harm, it just doesn't do what you
  1883.         want it to di.
  1884.  
  1885.    SEE ALSO
  1886.  
  1887.         gtlayout.library/LT_NewMenuTagList
  1888. gtlayout.library/LT_NewA                              gtlayout.library/LT_NewA
  1889.  
  1890.    NAME
  1891.  
  1892.         LT_NewA -- Add a new object to the user interface tree.
  1893.  
  1894.    SYNOPSIS
  1895.  
  1896.         LT_NewA(Handle,Tags);
  1897.                  A0    A1
  1898.  
  1899.         VOID LT_NewA(LayoutHandle *,struct TagItem *);
  1900.  
  1901.         LT_New(Handle,...);
  1902.  
  1903.         VOID LT_New(LayoutHandle *,...);
  1904.  
  1905.    FUNCTION
  1906.  
  1907.         LT_NewA() is the routine you use to build the user interface,
  1908.         you give layout directions, design groups, etc. and finally
  1909.         call LT_BuildA() to turn these specifications into a window.
  1910.  
  1911.    INPUTS
  1912.  
  1913.         Handle - Pointer to LayoutHandle structure.
  1914.  
  1915.    TAGS
  1916.  
  1917.         This routine will accept almost all create-time tag items
  1918.         gadtools.library/CreateGadget will handle. In addition to
  1919.         this there are a bunch of extra gadget objects and extra
  1920.         tag items supported:
  1921.  
  1922.         All object types:
  1923.  
  1924.             LA_Type (LONG) - Type of the object to create, must be
  1925.                              one of the following:
  1926.  
  1927.                                  TEXT_KIND
  1928.                                  VERTICAL_KIND
  1929.                                  HORIZONTAL_KIND
  1930.                                  END_KIND
  1931.                                  FRAME_KIND
  1932.                                  BOX_KIND
  1933.                                  SLIDER_KIND
  1934.                                  LISTVIEW_KIND
  1935.                                  INTEGER_KIND
  1936.                                  STRING_KIND
  1937.                                  PASSWORD_KIND
  1938.                                  PALETTE_KIND
  1939.                                  BUTTON_KIND
  1940.                                  CHECKBOX_KIND
  1941.                                  NUMBER_KIND
  1942.                                  GAUGE_KIND
  1943.                                  CYCLE_KIND
  1944.                                  POPUP_KIND
  1945.                                  TAB_KIND
  1946.                                  MX_KIND
  1947.                                  XBAR_KIND
  1948.                                  YBAR_KIND
  1949.                                  FRACTION_KIND
  1950.                                  TAPEDECK_KIND
  1951.                                  LEVEL_KIND
  1952.                                  BOOPSI_KIND
  1953.  
  1954.             LA_LabelText (STRPTR) - The object label text to use.
  1955.  
  1956.             LA_LabelID (LONG) - The locale text ID of the string to
  1957.                                 use as the object label text.
  1958.  
  1959.                                 NOTE: LT_NewA() will fail if you forget
  1960.                                       to select a hook with LAHN_LocaleHook
  1961.                                       at LT_CreateHandleTagList.
  1962.  
  1963.             LA_ID (LONG) - The gadget ID to use for this object.
  1964.  
  1965.                            NOTE: User ID values *MUST* be greater than 0,
  1966.                                  negative values are reserved for internal
  1967.                                  use.
  1968.  
  1969.             LA_Chars (LONG) - The width of this object measured in
  1970.                 characters. If each character of the user interface
  1971.                 font is 8 pixels wide an object with LA_Chars set to
  1972.                 10 will usually be 80 pixels wide.
  1973.  
  1974.             LA_LabelChars (LONG) - This forces the internal gadget
  1975.                 label width the layout engine calculates during the
  1976.                 layout pass to a specific value. Note: this does
  1977.                 not work well with all objects.
  1978.  
  1979.                 (requires gtlayout.library v9 or higher)
  1980.  
  1981.             LA_LabelPlace (LONG) - Where to place the gadget label.
  1982.                 Not all objects will support all label positions:
  1983.  
  1984.                     PLACE_LEFT - Place label text left of object
  1985.                     PLACE_RIGHT - Place label text right of object
  1986.                     PLACE_ABOVE - Place label text above object
  1987.                     PLACE_IN - Place label text in object
  1988.                     PLACE_BELOW - Place label text below object
  1989.  
  1990.             LA_ExtraSpace (BOOL) - Add extra vertical/horizontal
  1991.                 space before this object.
  1992.                 Default: FALSE
  1993.  
  1994.             LA_ExtraFat (BOOL) - Make this object a bit larger
  1995.                 than its usual size.
  1996.                 Default: FALSE
  1997.  
  1998.             LA_NoKey (BOOL) - Don't let the user interface choose
  1999.                 a keyboard shortcut for this object.
  2000.                 Default: FALSE
  2001.  
  2002.             LA_HighLabel (BOOL) - Use highlight pen when rendering
  2003.                 the gadget label text.
  2004.                 Default: FALSE
  2005.  
  2006.             LA_BYTE (BYTE *) - Pointer to the variable that holds
  2007.                 the "current value" of the object. The layout engine
  2008.                 will retrieve this value initially during the creation
  2009.                 of the object and maintain it during its lifespan.
  2010.                 This means you do not need to worry about checking
  2011.                 the state of the object, the user interface layout
  2012.                 engine will do it for you.
  2013.  
  2014.             LA_UBYTE (UBYTE *) - Pointer to the variable that holds
  2015.                 the "current value" of the object. The layout engine
  2016.                 will retrieve this value initially during the creation
  2017.                 of the object and maintain it during its lifespan.
  2018.                 This means you do not need to worry about checking
  2019.                 the state of the object, the user interface layout
  2020.                 engine will do it for you.
  2021.  
  2022.             LA_WORD (WORD *) - Pointer to the variable that holds
  2023.                 the "current value" of the object. The layout engine
  2024.                 will retrieve this value initially during the creation
  2025.                 of the object and maintain it during its lifespan.
  2026.                 This means you do not need to worry about checking
  2027.                 the state of the object, the user interface layout
  2028.                 engine will do it for you.
  2029.  
  2030.             LA_UWORD (UWORD *) - Pointer to the variable that holds
  2031.                 the "current value" of the object. The layout engine
  2032.                 will retrieve this value initially during the creation
  2033.                 of the object and maintain it during its lifespan.
  2034.                 This means you do not need to worry about checking
  2035.                 the state of the object, the user interface layout
  2036.                 engine will do it for you.
  2037.  
  2038.             LA_BOOL (BOOL *) - Pointer to the variable that holds
  2039.                 the "current value" of the object. The layout engine
  2040.                 will retrieve this value initially during the creation
  2041.                 of the object and maintain it during its lifespan.
  2042.                 This means you do not need to worry about checking
  2043.                 the state of the object, the user interface layout
  2044.                 engine will do it for you.
  2045.  
  2046.             LA_LONG (LONG *) - Pointer to the variable that holds
  2047.                 the "current value" of the object. The layout engine
  2048.                 will retrieve this value initially during the creation
  2049.                 of the object and maintain it during its lifespan.
  2050.                 This means you do not need to worry about checking
  2051.                 the state of the object, the user interface layout
  2052.                 engine will do it for you.
  2053.  
  2054.             LA_ULONG (ULONG *) - Pointer to the variable that holds
  2055.                 the "current value" of the object. The layout engine
  2056.                 will retrieve this value initially during the creation
  2057.                 of the object and maintain it during its lifespan.
  2058.                 This means you do not need to worry about checking
  2059.                 the state of the object, the user interface layout
  2060.                 engine will do it for you.
  2061.  
  2062.             LA_STRPTR (STRPTR) - Pointer to the variable that holds
  2063.                 the "current value" of the object. The layout engine
  2064.                 will retrieve this value initially during the creation
  2065.                 of the object and maintain it during its lifespan.
  2066.                 This means you do not need to worry about checking
  2067.                 the state of the object, the user interface layout
  2068.                 engine will do it for you.
  2069.  
  2070.             LA_FRACTION (FRACTION *) - Pointer to the variable that holds
  2071.                 the "current value" of the object. The layout engine
  2072.                 will retrieve this value initially during the creation
  2073.                 of the object and maintain it during its lifespan.
  2074.                 This means you do not need to worry about checking
  2075.                 the state of the object, the user interface layout
  2076.                 engine will do it for you.
  2077.  
  2078.             TEXT_KIND:
  2079.  
  2080.                 LATX_Picker (BOOL) - Attach a `select' button to the
  2081.                     right hand side of the text display.
  2082.                     Default: FALSE
  2083.  
  2084.                 LATX_LockSize (BOOL) - After doing the initial layout
  2085.                     for this object, do not adapt its size again during
  2086.                     subsequent layouts. This is particularly useful if
  2087.                     you have a TEXT_KIND object in a paged group
  2088.                     and update its contents later. You need
  2089.                     to specify an object width using LA_Chars, otherwise
  2090.                     the layout engine may make it not wide enough to
  2091.                     display any text.
  2092.                     (requires gtlayout.library v15 or higher)
  2093.  
  2094.  
  2095.             VERTICAL_KIND (group to align objects vertically):
  2096.             HORIZONTAL_KIND (group to align objects horizontally):
  2097.  
  2098.                 LAGR_Spread (BOOL) - Place all objects in this
  2099.                     group with roughly the same amount of space
  2100.                     between them.
  2101.                     Default: FALSE
  2102.  
  2103.                 LAGR_SameSize (BOOL) - Make all objects in this
  2104.                     group the same size (for vertical groups:
  2105.                     the same height, for horizontal groups:
  2106.                     the same width).
  2107.                     Default: FALSE
  2108.  
  2109.                 LAGR_LastAttributes (BOOL) - Try to copy the
  2110.                     size of the previous group for this new
  2111.                     group. May not work if this group turns
  2112.                     out to be larger than the previous group.
  2113.                     Default: FALSE
  2114.  
  2115.                 LAGR_ActivePage (LONG) - Organize all child
  2116.                     groups as pages which can be flipped through
  2117.                     using LT_SetAttributes(). You need to
  2118.                     specify the number of the first page to
  2119.                     display, starting from 0.
  2120.  
  2121.                     NOTE: Specifying this tag actually enables
  2122.                           the paging feature. If you omit this
  2123.                           tag calls to flip to a specific
  2124.                           page will fail.
  2125.  
  2126.                     Default: No paging
  2127.  
  2128.                 LAGR_Frame (BOOL) - Draw a recessed frame around
  2129.                     this group, even if there is no group label.
  2130.                     (requires gtlayout.library v7 or higher)
  2131.  
  2132.                 LAGR_IndentX (BOOL) - Add extra horizontal indentation
  2133.                     for this group.
  2134.                     (requires gtlayout.library v10 or higher)
  2135.  
  2136.                 LAGR_IndentY (BOOL) - Add extra vertical indentation
  2137.                     for this group.
  2138.                     (requires gtlayout.library v10 or higher)
  2139.  
  2140.                 LAGR_NoIndent (BOOL) - Inhibit automatic size adjustion
  2141.                     and centring of this group if it is smaller than
  2142.                     the neighbouring groups.
  2143.                     (requires gtlayout.library v21 or higher)
  2144.  
  2145.  
  2146.             FRAME_KIND (fixed size general purpose display,
  2147.                 you may render into it):
  2148.  
  2149.                 LAFR_InnerWidth (LONG) - Inner width of the
  2150.                     display box.
  2151.  
  2152.                 LAFR_InnerHeight (LONG) - Inner height of the
  2153.                     display box.
  2154.  
  2155.                 LAFR_DrawBox (BOOL) - Draw a recessed bevel box
  2156.                     around the display box.
  2157.                     Default: FALSE
  2158.  
  2159.                 LAFR_RefreshHook (struct Hook *) - Hook to call
  2160.                     when refreshing/redrawing this object. See
  2161.                     gtlayout.h for more information.
  2162.                     (requires gtlayout.library v9 or higher)
  2163.  
  2164.  
  2165.             XBAR_KIND (horizontal separator bar):
  2166.  
  2167.                 LAXB_FullSize (BOOL) - Make this separator bar span
  2168.                     the entire window width.
  2169.  
  2170.  
  2171.             BOX_KIND (multiline text display):
  2172.  
  2173.                 LABX_Labels (STRPTR *) - The label texts to display
  2174.                     on the right hand side of the box. Terminate
  2175.                     this array with NULL.
  2176.  
  2177.                 LABX_Lines (STRPTR *) - The text to display in the
  2178.                     box. Terminate this array with NULL.
  2179.  
  2180.                 LABX_Rows (LONG) - The width of this object in
  2181.                     characters. The layout routine will try to make
  2182.                     sure that the given number of characters will
  2183.                     fit into a single line of text in this box.
  2184.                     This may be a problem with proportional spaced
  2185.                     fonts.
  2186.  
  2187.                 LABX_AlignText (LONG) - Controls how text is aligned
  2188.                     in box lines:
  2189.  
  2190.                         ALIGNTEXT_LEFT - Align text to the left edge
  2191.                         ALIGNTEXT_CENTERED - Centre the text
  2192.                         ALIGNTEXT_RIGHT - Align text to the right edge
  2193.                         ALIGNTEXT_PAD - Pad text lines
  2194.  
  2195.                     Default: ALIGNTEXT_LEFT
  2196.  
  2197.                 LABX_DrawBox (BOOL) - Draw a recessed bevel box
  2198.                     around the text box.
  2199.                     Default: FALSE
  2200.  
  2201.                 LABX_FirstLabel (LONG) - Locale string ID of the first
  2202.                     text to use as a box label. Works in conjunction
  2203.                     with LABX_LastLabel.
  2204.  
  2205.                 LABX_LastLabel (LONG) - Locale string ID of the last
  2206.                     text to use as a box label. Works in conjunction
  2207.                     with LABX_FirstLabel. When building the interface the
  2208.                     code will loop from FirstLabel..LastLabel, look
  2209.                     up the corresponding locale strings and use the
  2210.                     data to make up the label text to appear at the
  2211.                     right hand side of the box.
  2212.  
  2213.                 LABX_LabelTable (LONG *) - Pointer to an array of IDs
  2214.                     to use for building the box labels. This requires
  2215.                     that a locale hook is provided with the layout handle.
  2216.                     The array is terminated by -1.
  2217.  
  2218.                 LABX_ReserveSpace (BOOL) - Allocate extra memory to hold
  2219.                     the contents of the lines displayed. This avoids nasty
  2220.                     side-effects when refreshing this object.
  2221.                     Default: FALSE
  2222.  
  2223.             FRACTION_KIND:
  2224.  
  2225.                 LAFC_MaxChars (LONG) - Maximum number of characters to
  2226.                     fit into the entry field.
  2227.                     Default: 16
  2228.  
  2229.                 LAFC_Number (FIXED) - Fixed point number to use for
  2230.                     this object.
  2231.                     Default: 0.0
  2232.  
  2233.                 LAFC_LastGadget (BOOL) - When cycling through the
  2234.                     text entry fields, stop cycling after leaving
  2235.                     this object.
  2236.                     Default: FALSE
  2237.  
  2238.                 LAFC_Min (FIXED) - Minimum value allowed for this
  2239.                     object.
  2240.  
  2241.                 LAFC_Max (FIXED) - Maximum value allowed for this
  2242.                     object.
  2243.  
  2244.                 LAFC_HistoryLines (LONG) - Maximum number of entries
  2245.                     to keep as a backlog.
  2246.                     Default: 0
  2247.  
  2248.                 LAFC_HistoryHook (struct Hook *) - Hook code to call
  2249.                     when entering a number into the backlog. See
  2250.                     gtlayout.h for more information.
  2251.                     Default: NULL
  2252.  
  2253.                 LAFC_Activate (BOOL) - When the window opens, make this
  2254.                     gadget the active one.
  2255.  
  2256.                     NOTE: There can be only one gadget of this type
  2257.                           per window.
  2258.  
  2259.                     Default: FALSE
  2260.                     (requires gtlayout.library v21 or higher)
  2261.  
  2262.             SLIDER_KIND:
  2263.  
  2264.                 LASL_FullCheck: TRUE will cause the code to rattle
  2265.                     through all possible slider settings, starting
  2266.                     from the minimum value, ending at the maximum value.
  2267.                     While this may be a good idea for a display
  2268.                     function to map slider levels to text strings
  2269.                     of varying length it might be a problem when
  2270.                     it comes to display a range of numbers from
  2271.                     1 to 40,000: the code will loop through
  2272.                     40,000 iterations trying to find the longest
  2273.                     string.
  2274.  
  2275.                     FALSE will cause the code to calculate the
  2276.                     longest level string based only on the
  2277.                     minimum and the maximum value to check.
  2278.                     While this is certainly a good a idea when
  2279.                     it comes to display a range of numbers from
  2280.                     1 to 40,000 as only two values will be
  2281.                     checked the code may fail to produce
  2282.                     accurate results for sliders using display
  2283.                     functions mapping slider levels to strings.
  2284.  
  2285.                     Default: TRUE
  2286.  
  2287.             LEVEL_KIND:
  2288.  
  2289.                 All tags are supported which SLIDER_KIND supports.
  2290.                 The gadget level display however, can only be aligned
  2291.                 to the left border.
  2292.  
  2293.             LISTVIEW_KIND:
  2294.  
  2295.                 LALV_ExtraLabels (STRPTR *) - Place extra line
  2296.                     labels at the right of the box. Terminate
  2297.                     this array with NULL.
  2298.  
  2299.                 LALV_Labels (STRPTR *) - The labels to display
  2300.                     inside the box, you can pass this array of
  2301.                     strings in rather than passing an initialized
  2302.                     List of text via GTLV_Labels. Terminate
  2303.                     this array with NULL.
  2304.  
  2305.                 LALV_CursorKey (BOOL) - Let the user operate this
  2306.                     listview using the cursor keys.
  2307.  
  2308.                     NOTE: there can be only one single listview
  2309.                           per window to sport this feature.
  2310.  
  2311.                     Default: FALSE
  2312.  
  2313.                 LALV_Lines (LONG) - The number of text lines this
  2314.                     listview is to display.
  2315.  
  2316.                 LALV_Link (LONG) - The Gadget ID of a string gadget
  2317.                     to attach to this listview. NOTE: you need to
  2318.                     add the Gadget in question before you add the
  2319.                     listview to refer to it or the layout routine
  2320.                     will get confused.
  2321.                     Passing the value NIL_LINK will create a listview
  2322.                     which displays the currently selected item, otherwise
  2323.                     you will get a read-only list.
  2324.  
  2325.                 LALV_FirstLabel (LONG) - Locale string ID of the first
  2326.                     text to use as a list label. Works in conjunction
  2327.                     with LALV_LastLabel.
  2328.  
  2329.                 LALV_LastLabel (LONG) - Locale string ID of the last
  2330.                     text to use as a list label. Works in conjunction
  2331.                     with LALV_FirstLabel. When building the interface the
  2332.                     code will loop from FirstLabel..LastLabel, look
  2333.                     up the corresponding locale strings and use the
  2334.                     data to make up the label text to appear in the
  2335.                     list.
  2336.  
  2337.                 LALV_LabelTable (LONG *) - Pointer to an array of IDs
  2338.                     to use for building the listview contents. This requires
  2339.                     that a locale hook is provided with the layout handle.
  2340.                     The array is terminated by -1.
  2341.  
  2342.                 LALV_MaxGrowX (LONG) - Maximum width of this object
  2343.                     measured in characters. When the first layout pass
  2344.                     is finished and there is still enough space left
  2345.                     to make the listview wider, the width is increased
  2346.                     until it hits the limit specified using this tag.
  2347.  
  2348.                     NOTE: there can be only one single listview
  2349.                           per window to sport this feature.
  2350.  
  2351.                     Default: 0
  2352.  
  2353.                 LALV_MaxGrowY (LONG) - Maximum height of this object
  2354.                     measured in lines. When the first layout pass is
  2355.                     finished and there is till enough space left to
  2356.                     make the listview higher, the height is increased
  2357.                     until it hits the limit specified using this tag.
  2358.  
  2359.                     NOTE: there can be only one single listview
  2360.                           per window to sport this feature.
  2361.  
  2362.                     Default: 0
  2363.  
  2364.                 LALV_ResizeX (BOOL) - Makes this listview resizable
  2365.                     in the horizontal direction, attaches a sizing
  2366.                     gadget to the window to open and handles window
  2367.                     resize operations automatically.
  2368.                     (requires gtlayout.library v9 or higher)
  2369.  
  2370.                     NOTE: there can be only one single listview
  2371.                           per window to sport this feature.
  2372.  
  2373.                           Also listen to IDCMP_CLOSEWINDOW events
  2374.                           which may be generated if the layout
  2375.                           engine runs out of memory when rebuilding
  2376.                           the user interface.
  2377.  
  2378.                     Default: FALSE
  2379.  
  2380.                 LALV_ResizeY (BOOL) - Makes this listview resizable
  2381.                     in the vertical direction, attaches a sizing
  2382.                     gadget to the window to open and handles window
  2383.                     resize operations automatically.
  2384.                     (requires gtlayout.library v9 or higher)
  2385.  
  2386.                     NOTE: there can be only one single listview
  2387.                           per window to sport this feature.
  2388.  
  2389.                           Also listen to IDCMP_CLOSEWINDOW events
  2390.                           which may be generated if the layout
  2391.                           engine runs out of memory when rebuilding
  2392.                           the user interface.
  2393.  
  2394.                     Default: FALSE
  2395.  
  2396.                 LALV_MinChars (WORD) - Minimum width for this
  2397.                     object, measured in characters. Used in
  2398.                     conjunction with LALV_ResizeX.
  2399.                     (requires gtlayout.library v9 or higher)
  2400.  
  2401.                 LALV_MinLines (WORD) - Minimum height for this
  2402.                     object, measured in lines. Used in
  2403.                     conjunction with LALV_ResizeY.
  2404.                     (requires gtlayout.library v9 or higher)
  2405.  
  2406.                 LALV_LockSize (BOOL) - After doing the initial layout
  2407.                     for this object, do not adapt its size again during
  2408.                     subsequent layouts. This is particularly useful if
  2409.                     you have a LISTVIEW_KIND object in a paged group
  2410.                     and keep adding new entries to the list. You need
  2411.                     to specify an object width using LA_Chars, otherwise
  2412.                     the layout engine may make it not wide enough to
  2413.                     display any entries.
  2414.                     (requires gtlayout.library v8 or higher)
  2415.  
  2416.                 LALV_FlushLabelLeft (BOOL) - For a gadget label placed
  2417.                     above the listview align the text to the left edge
  2418.                     of the view.
  2419.                     (requires gtlayout.library v9 or higher)
  2420.  
  2421.                 LALV_TextAttr (struct TextAttr *) - You can specify a
  2422.                     fixed-width font to be used for the list display.
  2423.                     The TextAttr (or TTextAttr) you provide must be ready
  2424.                     to go so the layout code can open the font later.
  2425.  
  2426.                     To get the current system default font, which is
  2427.                     guaranteed to be fixed-width, pass ~0 instead of a
  2428.                     pointer to a TextAttr structure.
  2429.  
  2430.                     NOTE: The font *MUST* be fixed-width or the layout
  2431.                           will fail.
  2432.  
  2433.                           Choose your font in such a way that it matches
  2434.                           in width and height with the other probably
  2435.                           proportional-spaced user interface font.
  2436.  
  2437.                           If the layout engine decides to step down in
  2438.                           font size, all LISTVIEW_KIND objects which were
  2439.                           configured to use a special fixed-width font
  2440.                           will `forget' about it. This won't matter much
  2441.                           as the fonts the engine chooses will always be
  2442.                           fixed-width anyway.
  2443.  
  2444.                     (requires gtlayout.library v10 or higher)
  2445.  
  2446.                 LALV_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2447.                     which will be set to the gadget's current setting.
  2448.                     (requires gtlayout.library v23 or higher)
  2449.  
  2450.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2451.                           which may be generated if the layout
  2452.                           engine runs out of memory when rebuilding
  2453.                           the user interface.
  2454.             INTEGER_KIND:
  2455.  
  2456.                 LAIN_LastGadget (BOOL) - Pressing return with this
  2457.                     gadget active will stop activating the next
  2458.                     following string gadget type if TRUE is passed.
  2459.                     Default: FALSE
  2460.  
  2461.                 LAIN_Min (LONG) - Minimum accepted numeric value.
  2462.                     Default: -2147483647
  2463.  
  2464.                 LAIN_Max (LONG) - Maximum accepted numeric value.
  2465.                     Default:  2147483647
  2466.  
  2467.                 LAIN_UseIncrementers (BOOL) - Use TRUE to add incrementer
  2468.                     arrow buttons to the right of the numeric entry field.
  2469.                     These buttons will let you cycle through a set of
  2470.                     numbers to be displayed in the numeric entry field.
  2471.                     Default: FALSE
  2472.  
  2473.                 LAIN_HistoryLines (LONG) - Number of numbers entered to
  2474.                     keep as a backlog.
  2475.                     Default: 0
  2476.  
  2477.                 LAIN_HistoryHook (struct Hook *) - Hook code to call when
  2478.                     entering a number into the backlog. See gtlayout.h for
  2479.                     more information.
  2480.                     Default: NULL
  2481.  
  2482.                 LAIN_IncrementerHook (struct Hook *) - Hook code to call
  2483.                     when cycling through numeric values. See gtlayout.h for
  2484.                     more information.
  2485.                     Default: NULL
  2486.  
  2487.                 LAIN_Activate (BOOL) - When the window opens, make this
  2488.                     gadget the active one.
  2489.  
  2490.                     NOTE: There can be only one gadget of this type
  2491.                           per window.
  2492.  
  2493.                     Default: FALSE
  2494.                     (requires gtlayout.library v21 or higher)
  2495.  
  2496.             STRING_KIND:
  2497.  
  2498.                 LAST_LastGadget (BOOL) - Pressing return with this
  2499.                     gadget active will stop activating the next
  2500.                     following string gadget type if TRUE is passed.
  2501.                     Default: FALSE
  2502.  
  2503.                 LAST_Link (LONG) - Gadget ID of the listview to attach
  2504.                     this string gadget to. NOTE: you need to
  2505.                     add the string gadget before you add the
  2506.                     listview to refer to it or the layout routine
  2507.                     will get confused.
  2508.  
  2509.                 LAST_Picker (BOOL) - Attach a `select' button to the
  2510.                     right hand side of the string gadget.
  2511.                     Default: FALSE
  2512.  
  2513.                 LAST_HistoryLines (LONG) - Number of lines to keep as
  2514.                     a backlog.
  2515.                     Default: 0
  2516.  
  2517.                 LAST_HistoryHook (struct Hook *) - Hook code to call
  2518.                     when entering a line into the backlog. See gtlayout.h
  2519.                     for more information.
  2520.                     Default: NULL
  2521.  
  2522.                 LAST_Activate (BOOL) - When the window opens, make this
  2523.                     gadget the active one.
  2524.  
  2525.                     NOTE: There can be only one gadget of this type
  2526.                           per window.
  2527.  
  2528.                     Default: FALSE
  2529.                     (requires gtlayout.library v21 or higher)
  2530.  
  2531.             PASSWORD_KIND (string gadget type which does not
  2532.                 display its contents):
  2533.  
  2534.                 LAPW_LastGadget (BOOL) - Pressing return with this
  2535.                     gadget active will stop activating the next
  2536.                     following string gadget type if TRUE is passed.
  2537.                     Default: FALSE
  2538.  
  2539.                 LAPW_HistoryLines (LONG) - Number of lines to keep as
  2540.                     a backlog.
  2541.                     Default: 0
  2542.  
  2543.                 LAPW_HistoryHook (struct Hook *) - Hook code to call
  2544.                     when entering a line into the backlog. See gtlayout.h
  2545.                     for more information.
  2546.                     Default: NULL
  2547.  
  2548.                 LAPW_Activate (BOOL) - When the window opens, make this
  2549.                     gadget the active one.
  2550.  
  2551.                     NOTE: There can be only one gadget of this type
  2552.                           per window.
  2553.  
  2554.                     Default: FALSE
  2555.                     (requires gtlayout.library v21 or higher)
  2556.  
  2557.                 This object type accepts all the GTST_#? tag items.
  2558.  
  2559.  
  2560.             PALETTE_KIND:
  2561.  
  2562.                 LAPA_SmallPalette (BOOL) - Make the palette display
  2563.                     a bit smaller than usual.
  2564.                     Default: FALSE
  2565.  
  2566.                 LAPA_Lines (LONG) - Number of lines the palette
  2567.                     display should cover.
  2568.                     Default: No preference
  2569.  
  2570.                 LAPA_UsePicker (BOOL) - This tag effectively changes the
  2571.                     gadget type. Instead of a list of colours to pick from
  2572.                     the user will see a rectangle filled in the selected
  2573.                     colour with a picker button next to it. This gadget
  2574.                     will generate IDCMP_IDCMPUPDATE events when the picker
  2575.                     button is pressed.
  2576.                     (requires gtlayout.library v10 or higher)
  2577.  
  2578.             BUTTON_KIND:
  2579.  
  2580.                 LA_Label (STRPTR)
  2581.                 LA_LabelID (LONG) - These two define the button label, i.e.
  2582.                     the text that is printed within the button box. Optionally,
  2583.                     this text may include newline characters ("\n") which will
  2584.                     cause the button text to be broken into several lines.
  2585.                     This particular feature requires gtlayout.library v12 or
  2586.                     higher. Single line label have always been supported.
  2587.  
  2588.                 LABT_ReturnKey (BOOL) - Let the user operate this
  2589.                     button by pressing the return key, making it the
  2590.                     so-called default button, or default choice. The
  2591.                     button select box will appear slightly bolder than
  2592.                     normal buttons are.
  2593.  
  2594.                     NOTE: there can be only one single button per
  2595.                           window to sport this feature.
  2596.  
  2597.                     Default: FALSE
  2598.  
  2599.                 LABT_EscKey (BOOL) - Let the user operate this
  2600.                     button by pressing the Escape key.
  2601.  
  2602.                     NOTE: there can be only one single button per
  2603.                           window to use this feature.
  2604.  
  2605.                     Default: FALSE
  2606.  
  2607.                 LABT_ExtraFat (BOOL) - Make this button a bit
  2608.                     larger than usual.
  2609.                     Default: FALSE
  2610.  
  2611.                 LABT_Lines (STRPTR *) - Use the given string array
  2612.                     to create a multiline gadget label. Terminate the
  2613.                     array with a NULL.
  2614.                     (requires gtlayout.library v12 or higher)
  2615.  
  2616.                 LABT_FirstLine (LONG) - Locale ID of first label line.
  2617.                     (requires gtlayout.library v12 or higher)
  2618.  
  2619.                 LABT_LastLine (LONG) - Locale ID of last label line.
  2620.                     (requires gtlayout.library v12 or higher)
  2621.  
  2622.                 LABT_DefaultCorrection (BOOL) - Make the button slightly
  2623.                     wider and taller so its size matches the default
  2624.                     button.
  2625.                     (requires gtlayout.library v21 or higher)
  2626.  
  2627.                 LABT_Smaller (BOOL) - Make this button a little smaller
  2628.                     than usual.
  2629.                     (requires gtlayout.library v21 or higher)
  2630.  
  2631.             GAUGE_KIND (general purpose progress report display):
  2632.  
  2633.                 LAGA_Percent (LONG) - Indicator position, can range
  2634.                     from 0..100.
  2635.                     Default: 0
  2636.  
  2637.                 LAGA_InfoLength (LONG) - Maximum number of characters
  2638.                     to reserve for text printed in the gauge display.
  2639.                     Default: 0
  2640.  
  2641.                 LAGA_InfoText (STRPTR) - Text to print in the gauge
  2642.                     display.
  2643.  
  2644.                 LAGA_Tenth (BOOL) - Instead of a continuously growing
  2645.                     bar you will get a set of exactly ten blocks,
  2646.                     each separated by a hairline.
  2647.                     Default: FALSE
  2648.                     (requires gtlayout.library v19 or higher)
  2649.  
  2650.  
  2651.             CYCLE_KIND:
  2652.  
  2653.                 LACY_FirstLabel (LONG) - Locale string ID of the first
  2654.                     text to use as a label. Works in conjunction
  2655.                     with LACY_LastLabel.
  2656.  
  2657.                 LACY_LastLabel (LONG) - Locale string ID of the last
  2658.                     text to use as a label. Works in conjunction
  2659.                     with LACY_FirstLabel. When building the interface the
  2660.                     code will loop from FirstLabel..LastLabel, look
  2661.                     up the corresponding locale strings and use the
  2662.                     data to make up the label text.
  2663.  
  2664.                 LACY_LabelTable (LONG *) - Pointer to an array of IDs
  2665.                     to use for building the cycle labels. This requires
  2666.                     that a locale hook is provided with the layout handle.
  2667.                     The array is terminated by -1.
  2668.  
  2669.                 LACY_TabKey (BOOL) - Connect this object to the tabulator
  2670.                     key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2671.                     to cycle to the previous entry.
  2672.  
  2673.                     NOTE: there can be only one single button per
  2674.                     window to use this feature.
  2675.  
  2676.                     Default: FALSE
  2677.                     (requires gtlayout.library v9 or higher)
  2678.  
  2679.                 LACY_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2680.                     which will be set to the gadget's current setting.
  2681.                     (requires gtlayout.library v7 or higher)
  2682.  
  2683.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2684.                           which may be generated if the layout
  2685.                           engine runs out of memory when rebuilding
  2686.                           the user interface.
  2687.  
  2688.             POPUP_KIND:
  2689.  
  2690.                 (This features requires gtlayout.library v22 or higher)
  2691.  
  2692.                 LAPU_FirstLabel (LONG) - Locale string ID of the first
  2693.                     text to use as a label. Works in conjunction
  2694.                     with LAPU_LastLabel.
  2695.  
  2696.                 LAPU_LastLabel (LONG) - Locale string ID of the last
  2697.                     text to use as a label. Works in conjunction
  2698.                     with LAPU_FirstLabel. When building the interface the
  2699.                     code will loop from FirstLabel..LastLabel, look
  2700.                     up the corresponding locale strings and use the
  2701.                     data to make up the label text.
  2702.  
  2703.                 LAPU_LabelTable (LONG *) - Pointer to an array of IDs
  2704.                     to use for building the cycle labels. This requires
  2705.                     that a locale hook is provided with the layout handle.
  2706.                     The array is terminated by -1.
  2707.  
  2708.                 LAPU_TabKey (BOOL) - Connect this object to the tabulator
  2709.                     key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2710.                     to cycle to the previous entry.
  2711.  
  2712.                     NOTE: there can be only one single button per
  2713.                     window to use this feature.
  2714.  
  2715.                     Default: FALSE
  2716.  
  2717.                 LAPU_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2718.                     which will be set to the gadget's current setting.
  2719.  
  2720.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2721.                           which may be generated if the layout
  2722.                           engine runs out of memory when rebuilding
  2723.                           the user interface.
  2724.  
  2725.             TAB_KIND:
  2726.  
  2727.                 (This features requires gtlayout.library v24 or higher)
  2728.  
  2729.                 LATB_FirstLabel (LONG) - Locale string ID of the first
  2730.                     text to use as a label. Works in conjunction
  2731.                     with LATB_LastLabel.
  2732.  
  2733.                 LATB_LastLabel (LONG) - Locale string ID of the last
  2734.                     text to use as a label. Works in conjunction
  2735.                     with LATB_FirstLabel. When building the interface the
  2736.                     code will loop from FirstLabel..LastLabel, look
  2737.                     up the corresponding locale strings and use the
  2738.                     data to make up the label text.
  2739.  
  2740.                 LATB_LabelTable (LONG *) - Pointer to an array of IDs
  2741.                     to use for building the cycle labels. This requires
  2742.                     that a locale hook is provided with the layout handle.
  2743.                     The array is terminated by -1.
  2744.  
  2745.                 LATB_TabKey (BOOL) - Connect this object to the tabulator
  2746.                     key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2747.                     to cycle to the previous entry.
  2748.  
  2749.                     NOTE: there can be only one single button per
  2750.                     window to use this feature.
  2751.  
  2752.                     Default: FALSE
  2753.  
  2754.                 LATB_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2755.                     which will be set to the gadget's current setting.
  2756.  
  2757.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2758.                           which may be generated if the layout
  2759.                           engine runs out of memory when rebuilding
  2760.                           the user interface.
  2761.  
  2762.                 LATB_FullSize (BOOL) - By default a TAB_KIND object
  2763.                     covers the entire width of the group it sits in.
  2764.                     With LATB_FullSize set to true it will cover the
  2765.                     width of the entire Window.
  2766.  
  2767.                     Default: FALSE
  2768.  
  2769.             MX_KIND:
  2770.  
  2771.                 LAMX_FirstLabel (LONG) - Locale string ID of the first
  2772.                     text to use as a label. Works in conjunction
  2773.                     with LAMX_LastLabel.
  2774.  
  2775.                 LAMX_LastLabel (LONG) - Locale string ID of the last
  2776.                     text to use as a label. Works in conjunction
  2777.                     with LAMX_FirstLabel. When building the interface the
  2778.                     code will loop from FirstLabel..LastLabel, look
  2779.                     up the corresponding locale strings and use the
  2780.                     data to make up the label text.
  2781.  
  2782.                 LAMX_LabelTable (LONG *) - Pointer to an array of IDs
  2783.                     to use for building the radio labels. This requires
  2784.                     that a locale hook is provided with the layout handle.
  2785.                     The array is terminated by -1.
  2786.  
  2787.                 LAMX_TabKey (BOOL) - Connect this object to the tabulator
  2788.                     key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2789.                     to cycle to the previous entry.
  2790.  
  2791.                     NOTE: there can be only one single button per
  2792.                     window to use this feature.
  2793.  
  2794.                     Default: FALSE
  2795.                     (requires gtlayout.library v9 or higher)
  2796.  
  2797.                 LAMX_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2798.                     which will be set to the gadget's current setting.
  2799.                     (requires gtlayout.library v7 or higher)
  2800.  
  2801.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2802.                           which may be generated if the layout
  2803.                           engine runs out of memory when rebuilding
  2804.                           the user interface.
  2805.  
  2806.             SCROLLER_KIND:
  2807.  
  2808.                 LASC_Thin (BOOL) - Make the scroller a bit thinner
  2809.                     than usual.
  2810.                     Default: FALSE
  2811.  
  2812.             TAPEDECK_KIND:
  2813.  
  2814.                 LATD_ButtonType (LONG) - Select the image to display
  2815.                     in the button, must be one of the following:
  2816.  
  2817.                         DTBT_BACKWARD
  2818.                             "<<" Symbol
  2819.  
  2820.                         DTBT_FORWARD
  2821.                             ">>" Symbol
  2822.  
  2823.                         DTBT_PREVIOUS
  2824.                             "|<" Symbol
  2825.  
  2826.                         DTBT_NEXT
  2827.                             ">|" Symbol
  2828.  
  2829.                         DTBT_STOP
  2830.                             Stop symbol (filled square)
  2831.  
  2832.                         DTBT_PAUSE
  2833.                             Pause symbol (broken square)
  2834.  
  2835.                         DTBT_RECORD
  2836.                             Record symbol (filled circle)
  2837.  
  2838.                         DTBT_REWIND
  2839.                             "<" symbol
  2840.  
  2841.                         DTBT_EJECT
  2842.                             Eject symbol (broken upward pointing arrow)
  2843.  
  2844.                         DTBT_PLAY
  2845.                             ">" symbol
  2846.  
  2847.                 LATD_Toggle (BOOL) - Make this object a toggle-select
  2848.                     button.
  2849.                     Default: FALSE
  2850.  
  2851.                 LATD_Pressed (BOOL) - Make this button appear to be
  2852.                     pressed.
  2853.  
  2854.                     NOTE: requires "LATD_Toggle,TRUE" attribute.
  2855.  
  2856.                     Default: FALSE
  2857.  
  2858.                 LATD_Smaller (BOOL) - Make this button a bit smaller
  2859.                     than usual.
  2860.                     Default: FALSE
  2861.  
  2862.                 LATD_Tick (BOOL) - Hear IDCMP_GADGETUP events while the
  2863.                     buttons is being pressed; the IntuiMessage->Code entry
  2864.                     will be 0 while the button is being pressed, and
  2865.                     will be 1 as soon as the button is released.
  2866.  
  2867.                     Default: FALSE
  2868.  
  2869.                     (requires gtlayout.library v12 or higher)
  2870.  
  2871.             BOOPSI_KIND:
  2872.  
  2873.                 (requires gtlayout.library v10 or higher)
  2874.  
  2875.                 LABO_TagCurrent (Tag) - The Tag ID that represents the
  2876.                     current object value. For PROPGCLASS this would be
  2877.                     PGA_Top.
  2878.  
  2879.                 LABO_TagTextAttr (Tag) - The Tag ID that represents the
  2880.                     TextAttr value the object expects. For gadgets this
  2881.                     would be GA_TextAttr.
  2882.  
  2883.                 LABO_TagDrawInfo (Tag) - The Tag ID that represents the
  2884.                     DrawInfo value the object expects.
  2885.  
  2886.                 LABO_TagLink (Tag) - The Tag ID that represents a pointer
  2887.                     to a different object the object expects. For the
  2888.                     colorwheel.gadget this would be WHEEL_GradientSlider.
  2889.  
  2890.                 LABO_TagScreen (Tag) - The Tag ID that represents the
  2891.                     screen the object expects. For the colorwheel.gadget
  2892.                     this would be WHEEL_Screen.
  2893.  
  2894.                 LABO_Link (LONG) - The ID of the object this object should
  2895.                     be linked to. This will be resolved later when gadgets
  2896.                     are created.
  2897.  
  2898.                     NOTE: Forward references are not resolved, only backward
  2899.                           references are allowed. This means that if you wish
  2900.                           to link object A to object B, object A must be
  2901.                           created before object B is created.
  2902.  
  2903.                 LABO_ClassInstance (Class *) - This is the first parameter you would
  2904.                     pass to NewObjectA().
  2905.  
  2906.                     NOTE: Only classes derived from gadgetclass and gadgetclass itself
  2907.                           may be used.
  2908.  
  2909.                 LABO_ClassName (STRPTR) - This is the second parameter you would
  2910.                     pass to NewObject().
  2911.  
  2912.                     NOTE: Only classes derived from gadgetclass and gadgetclass itself
  2913.                           may be used.
  2914.  
  2915.                 LABO_ClassLibraryName (STRPTR) - This tag is particularly useful
  2916.                     for gadget class implementations wrapped into libraries, such as
  2917.                     colorwheel.gadget. When opened, they make the classes they
  2918.                     represent publicly available so subsequent calls to
  2919.                     NewObject(NULL,<Classname>,...) can be made. The
  2920.                     LABO_ClassLibraryName tag will cause gtlayout.library to open
  2921.                     the class library before any calls to NewObject() are made.
  2922.  
  2923.                     NOTE: Only classes derived from gadgetclass and gadgetclass itself
  2924.                           may be used.
  2925.  
  2926.                           The LABO_ClassLibraryName tag requires that you specify the
  2927.                           class name with the LABO_ClassName. It is not enough to
  2928.                           just use the LABO_ClassLibraryName tag.
  2929.  
  2930.                 LABO_ExactWidth (WORD) - This is the exact width of the object to
  2931.                     use. This effectively overrides whatever you specified using
  2932.                     the LA_Chars tag and keeps gtlayout.library from shrinking and
  2933.                     expanding the object as needed.
  2934.  
  2935.                 LABO_ExactHeight (WORD) - This is the exact height of the object to
  2936.                     use. This effectively overrides whatever you specified using
  2937.                     the LA_Lines tag and keeps gtlayout.library from shrinking and
  2938.                     expanding the object as needed.
  2939.  
  2940.                 LABO_RelFontHeight (WORD) - This tag affects the height of the
  2941.                     object; when specified, it is derived from the user interface
  2942.                     font height plus the value given with LABO_RelFontHeight.
  2943.  
  2944.                 LABO_FullWidth (BOOL) - Use this tag if you wish the object to
  2945.                     cover the entire width of the group it resides within.
  2946.  
  2947.                 LABO_FullHeight (BOOL) - Use this tag if you wish the object to
  2948.                     cover the entire height of the group it resides within.
  2949.  
  2950.                 LABO_ActivateHook (struct Hook *) - Hook to invoke when the
  2951.                     layout engine decides that this particular object should
  2952.                     be activated. The hook is called with the following
  2953.                     parameters:
  2954.  
  2955.                     Success = ActivateFunc(struct Hook *Hook,LayoutHandle *Handle,
  2956.                       D0                                 A0                  A2
  2957.  
  2958.                                  Object *object)
  2959.                                            A1
  2960.  
  2961.                     The object pointer actually refers to the instance of the
  2962.                     BOOPSI object created. Return FALSE if your object could not
  2963.                     be activated, TRUE if it worked. If you return TRUE, no special
  2964.                     keyboard event will be generated.
  2965.  
  2966.                     (requires gtlayout.library v13 or higher)
  2967.  
  2968.                 NOTE: All tags passed to LT_New() for BOOPSI_KIND objects are
  2969.                       passed through to NewObjectA() later. The library makes
  2970.                       a copy of the tag item list, so all data valid in the
  2971.                       scope when LT_New() iss called must also be valid later
  2972.                       when LT_Build() is invoked.
  2973.  
  2974.                       The gadget label is *NOT* passed through to the object,
  2975.                       it effectively receives the label a plain gadtools object
  2976.                       would receive, similar to what happens to FRAME_KIND
  2977.                       objects and the like.
  2978.  
  2979.    RESULT
  2980.  
  2981.         none
  2982. gtlayout.library/LT_NewLevelWidth                  gtlayout.library/LT_NewLevelWidth
  2983.  
  2984.    NAME
  2985.  
  2986.         LT_NewLevelWidth -- Determine the maximum width of a SLIDER_KIND
  2987.                             level string. (V14)
  2988.  
  2989.    SYNOPSIS
  2990.  
  2991.         Index = LT_LevelWidth(Handle,FormatString,DispFunc,Min,Max,MaxWidth,
  2992.           D0                    A0        A1         A2     D0  D1    A3
  2993.  
  2994.                                   MaxLen,FullCheck);
  2995.                                     D3      D2
  2996.  
  2997.         LONG LT_LevelWidth(LayoutHandle *,STRPTR,
  2998.                            LONG (*)(struct Gadget *,WORD),LONG,LONG,LONG *,
  2999.                            LONG *,BOOL);
  3000.  
  3001.    FUNCTION
  3002.  
  3003.         In order to make room for the level text displayed by a
  3004.         SLIDER_KIND object one needs to know how much space the
  3005.         longest level string will occupy. Otherwise, the level
  3006.         text may overwrite the gadget label text or the slider
  3007.         container. This routine will rattle through all possible
  3008.         slider settings (as given via the Min and the Max
  3009.         level values) and determine the longest label string
  3010.         according to the font used.
  3011.  
  3012.    INPUTS
  3013.  
  3014.         Handle - Pointer to a LayoutHandle structure, as returned by
  3015.                  a call to LT_CreateHandleTags().
  3016.  
  3017.         FormatString - The sprintf() style formatting string to be used
  3018.                        to format the slider level settings into text.
  3019.                        This is the same string you would pass in via
  3020.                        the GTSL_LevelFormat tag when creating the
  3021.                        slider object.
  3022.                        Default: "%lD" for systems which have locale.library
  3023.                                 installed, "%ld" otherwise.
  3024.  
  3025.         DispFunc - A pointer to the function to filter the slider level
  3026.                    values. The result of this function will then be
  3027.                    used to format a string into the slider level text.
  3028.                    This is the same parameter you would pass in via
  3029.                    the GTSL_DispFunc tag when creating the slider
  3030.                    object.
  3031.  
  3032.                    NOTE: the routine will be called with a NULL Gadget
  3033.                          parameter, make sure your code will handle
  3034.                          this nicely.
  3035.  
  3036.                    Default: no display function
  3037.  
  3038.         Min - The smallest value the slider can be set to. This is
  3039.               same value you would pass in via GTSL_Min when creating
  3040.               the slider object.
  3041.  
  3042.         Max - The largest value the slider can be set to. This is
  3043.               same value you would pass in via GTSL_Max when creating
  3044.               the slider object.
  3045.  
  3046.         MaxWidth - Pointer to a place to store the width of the
  3047.                    longest level string in pixels. If you pass
  3048.                    in NULL instead of the address of a variable
  3049.                    no harm will be done.
  3050.  
  3051.         MaxLen - Pointer to a place to store the length of the
  3052.                  longest level string in characters. If you pass
  3053.                  in NULL instead of the address of a variable
  3054.                  no harm will be done.
  3055.  
  3056.  
  3057.         FullCheck - TRUE will cause the code to rattle through all
  3058.                     possible slider settings, starting from the
  3059.                     minimum value, ending at the maximum value.
  3060.                     While this may be a good idea for a display
  3061.                     function to map slider levels to text strings
  3062.                     of varying length it might be a problem when
  3063.                     it comes to display a range of numbers from
  3064.                     1 to 40,000: the code will loop through
  3065.                     40,000 iterations trying to find the longest
  3066.                     string.
  3067.  
  3068.                     FALSE will cause the code to calculate the
  3069.                     longest level string based only on the
  3070.                     minimum and the maximum value to check.
  3071.                     While this is certainly a good a idea when
  3072.                     it comes to display a range of numbers from
  3073.                     1 to 40,000 as only two values will be
  3074.                     checked the code may fail to produce
  3075.                     accurate results for sliders using display
  3076.                     functions mapping slider levels to strings.
  3077.  
  3078.     RESULT
  3079.  
  3080.         Index - The slider level which gives the longest
  3081.                 level string.
  3082.  
  3083.     NOTES
  3084.  
  3085.         This function does exactly what gtlayout.library/LT_LevelWidth
  3086.         does, but uses a slightly different register ordering. Namely,
  3087.         the MaxLen pointer is passed in D3 instead of A5.
  3088. gtlayout.library/LT_NewMenuTagList            gtlayout.library/LT_NewMenuTagList
  3089.  
  3090.    NAME
  3091.  
  3092.         LT_NewMenuTagList -- Allocate and layout menu items (V11)
  3093.  
  3094.    SYNOPSIS
  3095.  
  3096.         Menu = LT_NewMenuTagList(Tags)
  3097.          D0                       A0
  3098.  
  3099.         struct Menu *LT_NewMenuTagList(struct TagItem *);
  3100.  
  3101.         struct Menu *LT_NewMenuTags(...);
  3102.  
  3103.    FUNCTION
  3104.  
  3105.         Allocates Menus and MenuItems similar to LT_LayoutMenus().
  3106.  
  3107.         As of v18 this routine will validate menu mutual exclusion
  3108.         information.
  3109.  
  3110.    INPUTS
  3111.  
  3112.         Tags - Pointer to a list of tagitem values, as found
  3113.                in gtlayout.h
  3114.  
  3115.    TAGS
  3116.  
  3117.         LAMN_Screen (struct Screen *) - Pointer to the Screen
  3118.             the menu is to appear upon. This tag is mandatory,
  3119.             unless the LAMN_LayoutHandle tag is used.
  3120.  
  3121.         LAMN_TextAttr (struct TextAttr *) - Pointer to the
  3122.             TextAttr to use for the menu layout. If this tag
  3123.             is omitted the Screen->Font will be used.
  3124.  
  3125.         LAMN_Error (LONG *) - Pointer to variable to receive
  3126.             an error in case of failure.
  3127.  
  3128.         LAMN_AmigaGlyph (struct Image *) - Pointer to Image to
  3129.             use as the Amiga glyph in menus.
  3130.  
  3131.             NOTE: Ignored by intuition.library v37 and below.
  3132.  
  3133.         LAMN_CheckmarkGlyph (struct Image *) - Pointer to Image to
  3134.             use as the checkmark glyph in menus.
  3135.  
  3136.         LAMN_LayoutHandle (LayoutHandle *) - Pointer to a valid
  3137.             LayoutHandle as created by LT_CreateHandle. This tag
  3138.             provides all the information the single tags
  3139.             LAMN_Screen..LAMN_CheckmarkGlyph would otherwise
  3140.             need to provide.
  3141.  
  3142.         LAMN_TitleText (STRPTR) - Name of new menu to create.
  3143.             You may precede the name with the keyboard shortcut
  3144.             to assign to this menu item as follows:
  3145.  
  3146.                A\0Save as...
  3147.  
  3148.             This will create a menu item using the shortcut "A"
  3149.             and the title "Save as...".
  3150.  
  3151.         LAMN_TitleID (LONG) - Locale ID corresponding to the
  3152.             name of the new menu to create.
  3153.             You may precede the name with the keyboard shortcut
  3154.             to assign to this menu item as follows:
  3155.  
  3156.                A\0Save as...
  3157.  
  3158.             This will create a menu item using the shortcut "A"
  3159.             and the title "Save as...".
  3160.  
  3161.         LAMN_ItemText (STRPTR) - Name of new menu item to create.
  3162.             You may precede the name with the keyboard shortcut
  3163.             to assign to this menu item as follows:
  3164.  
  3165.                A\0Save as...
  3166.  
  3167.             This will create a menu item using the shortcut "A"
  3168.             and the title "Save as...".
  3169.  
  3170.         LAMN_ItemID (LONG) - Locale ID corresponding to the
  3171.             name of the new menu item to create.
  3172.             You may precede the name with the keyboard shortcut
  3173.             to assign to this menu item as follows:
  3174.  
  3175.                A\0Save as...
  3176.  
  3177.             This will create a menu item using the shortcut "A"
  3178.             and the title "Save as...".
  3179.  
  3180.         LAMN_SubText (STRPTR) - Name of new submenu item to create.
  3181.             You may precede the name with the keyboard shortcut
  3182.             to assign to this menu item as follows:
  3183.  
  3184.                A\0Save as...
  3185.  
  3186.             This will create a menu item using the shortcut "A"
  3187.             and the title "Save as...".
  3188.  
  3189.         LAMN_SubID (LONG) - Locale ID corresponding to the
  3190.             name of the new submenu item to create.
  3191.             You may precede the name with the keyboard shortcut
  3192.             to assign to this menu item as follows:
  3193.  
  3194.                A\0Save as...
  3195.  
  3196.             This will create a menu item using the shortcut "A"
  3197.             and the title "Save as...".
  3198.  
  3199.         LAMN_KeyText (STRPTR) - Pointer to the string whose first
  3200.             character will be used as the keyboard shortcut for
  3201.             this menu/submenu item.
  3202.  
  3203.         LAMN_KeyID (LONG) - Locale ID corresponding to the string whose
  3204.             first character will be used as the keyboard shortcut for
  3205.             this menu/submenu item.
  3206.  
  3207.         LAMN_CommandText (STRPTR) - Pointer to the string which
  3208.             will be used as the keyboard shortcut for this
  3209.             menu/submenu item.
  3210.  
  3211.         LAMN_CommandID (LONG) - Locale ID corresponding to the string
  3212.             which will be used as the keyboard shortcut for
  3213.             this menu/submenu item.
  3214.  
  3215.         LAMN_MutualExclude (ULONG) - Mutual exclusion information for
  3216.             this menu/submenu item.
  3217.  
  3218.         LAMN_UserData (APTR) - User data information for this
  3219.             menu/menu item/submenu item.
  3220.  
  3221.         LAMN_Disabled (BOOL) - Controls whether this
  3222.             menu/menu item/submenu item should be disabled.
  3223.  
  3224.         LAMN_CheckIt (BOOL) - Controls whether this menu/submenu item
  3225.             should be prepared to hold a checkmark. NOTE: This does
  3226.             not set the checkmark, use LAMN_Checked for this purpose.
  3227.  
  3228.         LAMN_Checked (BOOL) - Controls whether this menu/submenu item
  3229.             should be marked with a checkmark.
  3230.  
  3231.         LAMN_Toggle (BOOL) - Controls whether this menu/submenu item
  3232.             should be prepared to hold a checkmark the user is to
  3233.             toggle on demand. NOTE: this does not set the checkmark,
  3234.             use LAMN_Checked for this purpose.
  3235.  
  3236.         LAMN_Code (UWORD) - Raw key code to associate with this
  3237.             menu/submenu item. To find out if a rawkey event
  3238.             corresponds to this menu item use LT_FindMenuCommand.
  3239.  
  3240.         LAMN_Qualifier (ULONG) - Key qualifier to code to associate
  3241.             with this menu/submenu item. NOTE: the comparison does
  3242.             not distinguish between the left and right shift/caps/alt
  3243.             qualifier keys.
  3244.  
  3245.         LAMN_ID (ULONG) - Unique ID to associate with this
  3246.                           menu/menu item/submenu item. You can use this
  3247.                           later to look up this data using LT_GetMenuItem,
  3248.                           etc.
  3249.  
  3250.         LAMN_ExtraSpace (UWORD) - Number of pixels to put between
  3251.             neighbouring menu titles.
  3252.             Default: 0 pixels.
  3253.  
  3254.             (requires gtlayout.library v18 or higher)
  3255.  
  3256.    EXAMPLE
  3257.  
  3258.         The following tagitem list:
  3259.  
  3260.             LAMN_TitelText,     "Project"
  3261.              LAMN_ItemText,     "New",
  3262.               LAMN_KeyText,     "N",
  3263.              LAMN_ItemText,     "Open...",
  3264.               LAMN_KeyText,     "O",
  3265.              LAMN_ItemText,     NM_BARLABEL,
  3266.              LAMN_ItemText,     "Save",
  3267.               LAMN_KeyText,     "S",
  3268.              LAMN_ItemText,     "A\0Save As...",
  3269.              LAMN_ItemText,     NM_BARLABEL,
  3270.              LAMN_ItemText,     "Print...",
  3271.               LAMN_KeyText,     "P",
  3272.              LAMN_ItemText,     NM_BARLABEL,
  3273.              LAMN_ItemText,     "Help...",
  3274.               LAMN_CommandText, "[Help]",
  3275.              LAMN_ItemText,     NM_BARLABEL,
  3276.              LAMN_ItemText,     "Quit...",
  3277.               LAMN_KeyText,     "Q",
  3278.             TAG_DONE
  3279.  
  3280.         Will create the following menu:
  3281.  
  3282.         +-------+
  3283.         |Project|
  3284.         +-------+------+
  3285.         |New         aN|
  3286.         |Open...     aO|
  3287.         |~~~~~~~~~~~~~~|
  3288.         |Save        aS|
  3289.         |Save As...  aA|
  3290.         |~~~~~~~~~~~~~~|
  3291.         |Print...    aP|
  3292.         |~~~~~~~~~~~~~~|
  3293.         |Help... [Help]|
  3294.         |~~~~~~~~~~~~~~|
  3295.         |Quit...     aQ|
  3296.         +--------------+
  3297.  
  3298.    RESULT
  3299.  
  3300.         Menu - Pointer to Menu structure, ready to pass to
  3301.                SetMenuStrip(), NULL on failure.
  3302.  
  3303.    NOTES
  3304.  
  3305.         You may freely add, remove, spindle & mutilate the contents of the
  3306.         menu strip created, just don't trash or disconnect the base menu
  3307.         entry this routine creates as all menu memory tracking data is
  3308.         connected with it.
  3309.  
  3310.    SEE ALSO
  3311.  
  3312.         gtlayout.library/LT_FindCommandItem
  3313.         gtlayout.library/LT_GetMenuItem
  3314.         gtlayout.library/LT_LayoutMenuA
  3315.         gtlayout.library/LT_MenuControlTagList
  3316.         gtlayout.library/LT_NewMenuTemplate
  3317.         intuition.library/SetMenuStrip
  3318. gtlayout.library/LT_NewMenuTemplate            gtlayout.library/LT_NewMenuTemplate
  3319.  
  3320.    NAME
  3321.  
  3322.         LT_NewMenuTemplate -- Allocate and layout menu items (V11)
  3323.  
  3324.    SYNOPSIS
  3325.  
  3326.         Menu = LT_NewMenuTemplate(Screen,TextAttr,AmigaGlyph,CheckmarkGlyph,
  3327.          D0                         A0      A1        A2           A3
  3328.  
  3329.                                   Error,MenuTemplate);
  3330.                                     D0      D1
  3331.  
  3332.         
  3333.         struct Menu *LT_NewMenuTemplate(struct Screen *,struct TextAttr *,
  3334.                                         struct Image *,struct Image *,
  3335.                                         LONG *,struct NewMenu *);
  3336.  
  3337.    FUNCTION
  3338.  
  3339.         Allocates Menus and MenuItems similar to LT_LayoutMenus().
  3340.  
  3341.         As of v18 this routine will validate menu mutual exclusion
  3342.         information.
  3343.  
  3344.    INPUTS
  3345.  
  3346.         Screen - Pointer to the screen the menu will appear on. This
  3347.                  parameter is required and must not be omitted.
  3348.  
  3349.         TextAttr - Pointer to the TextAttr that should be used to
  3350.                    layout the menus. If this parameter is omitted,
  3351.                    Screen->Font will be used instead.
  3352.  
  3353.         AmigaGlyph - Pointer to the Image to use as the Amiga glyph.
  3354.                      This parameter may be omitted.
  3355.  
  3356.                      NOTE: Ignored by intuition.library v37 and below.
  3357.  
  3358.         CheckmarkGlyph - Pointer to the Image to use as the checkmark
  3359.                          glyph. This parameter may be omitted.
  3360.  
  3361.         Error - Pointer to receive error code in case the menu
  3362.                 creation or layout process fails. This parameter
  3363.                 may be omitted.
  3364.  
  3365.         MenuTemplate - Pointer to a series of NewMenu structures,
  3366.                        just as you would pass to
  3367.                        gtlayout.library/LT_LayoutMenuA.
  3368.  
  3369.    NOTES
  3370.  
  3371.         The menu created by this function cannot be used with the
  3372.         routines LT_MenuControlTagList, LT_FindMenuCommand and
  3373.         LT_GetMenuItem.
  3374.  
  3375.         You may freely add, remove, spindle & mutilate the contents of the
  3376.         menu strip created, just don't trash or disconnect the base menu
  3377.         entry this routine creates as all menu memory tracking data is
  3378.         connected with it.
  3379.  
  3380.    RESULT
  3381.  
  3382.         Menu - Pointer to Menu structure, ready to pass to
  3383.                SetMenuStrip(), NULL on failure.
  3384.  
  3385.    SEE ALSO
  3386.  
  3387.         gtlayout.library/LT_LayoutMenuA
  3388.         gtlayout.library/LT_NewMenuTagList
  3389.         intuition.library/SetMenuStrip
  3390. gtlayout.library/LT_PressButton                gtlayout.library/LT_PressButton
  3391.  
  3392.    NAME
  3393.  
  3394.         LT_PressButton -- Highlight a button so it looks as if the user
  3395.                           has selected it.
  3396.  
  3397.    SYNOPSIS
  3398.  
  3399.         LT_PressButton(Handle,ID);
  3400.                           A0  D0
  3401.  
  3402.         VOID LT_PressButton(LayoutHandle *,LONG);
  3403.  
  3404.    FUNCTION
  3405.  
  3406.         You can provide visual feedback for BUTTON_KIND objects by calling
  3407.         this routine. They will briefly appear to be selected and then
  3408.         fall back to their original states.
  3409.  
  3410.    INPUTS
  3411.  
  3412.         Handle - Pointer to LayoutHandle structure
  3413.  
  3414.         ID - ID of button object to highlight
  3415.  
  3416.    RESULT
  3417.  
  3418.         none
  3419. gtlayout.library/LT_RebuildTagList          gtlayout.library/LT_RebuildTagList
  3420.  
  3421.    NAME
  3422.  
  3423.         LT_RebuildTagList -- Rebuild the user interface after modifying it.
  3424.  
  3425.    SYNOPSIS
  3426.  
  3427.         Success = LT_RebuildTagList(Handle,Clear,TagList);
  3428.            D0                         A0    D0     A1
  3429.  
  3430.         BOOL LT_RebuildTagList(LayoutHandle *,BOOL,struct TagItem *);
  3431.  
  3432.         Success = LT_RebuildTags(Handle,Clear,...);
  3433.  
  3434.         BOOL LT_RebuildTags(LayoutHandle *,BOOL,...);
  3435.  
  3436.    FUNCTION
  3437.  
  3438.         Certain aspects of the user interface can be changed at run time,
  3439.         such as button labels. This routine will let you rebuild the interface
  3440.         based upon the data supplied at creation time and your subsequent
  3441.         changes. Before you make any vital changes, it is recommended to
  3442.         lock the window using LT_LockWindow() in order to avoid clashes
  3443.         with the Intuition and GadTools subsystems.
  3444.  
  3445.    INPUTS
  3446.  
  3447.         Handle - Pointer to LayoutHandle structure.
  3448.  
  3449.         Clear - Pass in TRUE if you wish to have the window contents
  3450.                 cleared before they are rebuild. This will introduce
  3451.                 some visual hashing.
  3452.  
  3453.         TagList - Attributes controlling the layout process.
  3454.  
  3455.    RESULT
  3456.  
  3457.         Success - TRUE indicates that the interface was rebuilt,
  3458.                   FALSE indicates trouble; it is recommended to
  3459.                   call LT_DeleteHandle() on your LayoutHandle as
  3460.                   soon as possible as the previous operation may
  3461.                   have left the user interface in an inoperable
  3462.                   state.
  3463.  
  3464.    TAGS
  3465.  
  3466.         LAWN_Bounds (struct IBox *) - Boundaries in which the window
  3467.             should be centered.
  3468.  
  3469.         LAWN_ExtraWidth (LONG) - Extra space to add to the window
  3470.             width.
  3471.  
  3472.         LAWN_ExtraHeight (LONG) - Extra height to add to the window
  3473.             height.
  3474. gtlayout.library/LT_ReplyIMsg                    gtlayout.library/LT_ReplyIMsg
  3475.  
  3476.    NAME
  3477.  
  3478.         LT_ReplyIMsg -- Dispose of an IntuiMessage received
  3479.  
  3480.    SYNOPSIS
  3481.  
  3482.         LT_ReplyIMsg(IntuiMessage);
  3483.                          A0
  3484.  
  3485.         VOID LT_ReplyIMsg(struct IntuiMessage *);
  3486.  
  3487.    FUNCTION
  3488.  
  3489.         This routine complements LT_GetIMsg().
  3490.  
  3491.    INPUTS
  3492.  
  3493.         IntuiMessage - Pointer to IntuiMessage structure,
  3494.                        passing NULL is harmless.
  3495.  
  3496.    NOTES
  3497.  
  3498.         Only pass IntuiMessages you received via LT_GetIMsg,
  3499.         or things will get tough.
  3500.  
  3501.    RESULT
  3502.  
  3503.         none
  3504.  
  3505.    SEE ALSO
  3506.  
  3507.         gtlayout.library/LT_GetIMsg
  3508. gtlayout.library/LT_SetAttributesA          gtlayout.library/LT_SetAttributesA
  3509.  
  3510.    NAME
  3511.  
  3512.         LT_SetAttributesA -- Change object attributes
  3513.  
  3514.    SYNOPSIS
  3515.  
  3516.         LT_SetAttributesA(Handle,ID,Tags);
  3517.                             A0   D0  A1
  3518.  
  3519.         VOID LT_SetAttributes(LayoutHandle *,LONG,struct TagItem *);
  3520.  
  3521.         LT_SetAttributes(Handle,ID,...);
  3522.  
  3523.         VOID LT_SetAttributes(LayoutHandle *,LONG,...);
  3524.  
  3525.    FUNCTION
  3526.  
  3527.         This routine passes the tag item list it gets directly
  3528.         over to GT_SetGadgetAttrsA(), so any tag items valid for
  3529.         gadtools.library can be used here as well. Some filtering
  3530.         may be done in order to stop objects from getting redrawn
  3531.         if this is not absolutely necessary.
  3532.  
  3533.    INPUTS
  3534.  
  3535.         Handle - Pointer to LayoutHandle.
  3536.  
  3537.         ID - ID number of the object to change. This is the same value
  3538.              you passed via LA_ID to LT_New() when you created this object.
  3539.  
  3540.         Tags - Attributes controlling object states.
  3541.  
  3542.    TAGS
  3543.  
  3544.         All gadtools.library tags are allowed, but not all are supported.
  3545.         In addition to these tags a few additional tag values are
  3546.         supported:
  3547.  
  3548.         LAHN_AutoActivate (BOOL) - Set to TRUE if you want the interface
  3549.             to always keep a string gadget active if possible. Hitting
  3550.             the return key will then cause the next following string
  3551.             gadget to get activated, either cycling through all the
  3552.             string gadgets available or stopping at the next string
  3553.             gadget to have the LAST_LastGadget attribute set.
  3554.  
  3555.         LAHN_UserData (APTR) - Store user specific data in the
  3556.             LayoutHandle->UserData entry.
  3557.             (requires gtlayout.library v9 or higher)
  3558.  
  3559.         LAHN_RawKeyFilter (BOOL) - Discard unprocessed IDCMP_RAWKEY
  3560.             events.
  3561.             Default: TRUE
  3562.             (requires gtlayout.library v13 or higher)
  3563.  
  3564.         LAHN_LocaleHook (struct Hook *) - The hook to call when
  3565.             locale string IDs are to be mapped to strings. The
  3566.             hook function is called with the following parameters:
  3567.  
  3568.             String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,
  3569.               D0                            A0                         A2
  3570.                               LONG ID)
  3571.                                    A1
  3572.  
  3573.             The function is to look up the string associated with the ID
  3574.             passed in and return the string.
  3575.  
  3576.         LAHN_ExitFlush (BOOL) - When the LayoutHandle is finally disposed
  3577.             of with LT_DeleteHandle() all variables maintained by the
  3578.             input handling code will be flushed. For example, if you
  3579.             would use the LA_STRPTR tag for STRING_KIND objects the
  3580.             last string gadget contents would be copied into the buffer
  3581.             pointed to by LA_STRPTR. If you do not want to use this
  3582.             feature, disable it with "LAHN_ExitFlush,FALSE".
  3583.             Default: TRUE
  3584.             (requires gtlayout.library v9 or higher)
  3585.  
  3586.         GAUGE_KIND:
  3587.  
  3588.             LAGA_Percent (LONG) - Percentage of the gauge to fill.
  3589.  
  3590.             LAGA_InfoText (STRPTR) - Text to be printed within the
  3591.                 gauge display, such as a percentage number.
  3592.  
  3593.         BOX_KIND:
  3594.  
  3595.             LABX_Index (LONG) - The number of the line to change, this
  3596.                 tag works in conjunction with the LABX_Text tag.
  3597.  
  3598.             LABX_Text (STRPTR) - The text to put into the line indicated
  3599.                 by the LABX_Index tag.
  3600.  
  3601.             LABX_Lines (STRPTR *) - The text to set for the box contents,
  3602.                 terminate the text array with NULL.
  3603.  
  3604.         HORIZONTAL_KIND:
  3605.         VERTICAL_KIND:
  3606.  
  3607.             LAGR_ActivePage (LONG) - Index number of page to display
  3608.                 witthin the group. NOTE: requires that this group was
  3609.                 created with the LAGR_ActivePage attribute set.
  3610.  
  3611.         FRACTION_KIND:
  3612.  
  3613.             LAFC_Number (FIXED) - Fixed point number to use
  3614.  
  3615.             LAFC_Min (FIXED) - Minimum allowed value for this
  3616.                 object.
  3617.  
  3618.             LAFC_Max (FIXED) - Maximum allowed value for this
  3619.                 object.
  3620.  
  3621.         INTEGER_KIND:
  3622.  
  3623.             LAIN_Min (LONG) - Minimum allowed value for this
  3624.                 object.
  3625.  
  3626.             LAIN_Max (LONG) - Maximum allowed value for this
  3627.                 object.
  3628.  
  3629.         PASSWORD_KIND:
  3630.  
  3631.             LAPW_String (STRPTR) - Secret text to use
  3632.  
  3633.         STRING_KIND:
  3634.  
  3635.             LAST_CursorPosition (LONG) - Repositions the cursor,
  3636.                 pass -1 to move it to the end of the string.
  3637.                 (requires gtlayout.library v7 or higher)
  3638.  
  3639.         TAPEDECK_KIND:
  3640.  
  3641.             LATD_Pressed (BOOL) - TRUE to make this button shown
  3642.                 as pressed, FALSE to show it in depressed state.
  3643.  
  3644.         BOOPSI_KIND:
  3645.  
  3646.             All tags are passed straight through to SetGadgetAttrs(..).
  3647.  
  3648.         All objects:
  3649.  
  3650.             LA_LabelText (STRPTR) - New gadget label text to use.
  3651.  
  3652.             LA_LabelID (LONG) - Locale text ID to use for this object.
  3653.  
  3654.    RESULT
  3655.  
  3656.        none
  3657. gtlayout.library/LT_ShowWindow                  gtlayout.library/LT_ShowWindow
  3658.  
  3659.    NAME
  3660.  
  3661.         LT_ShowWindow -- Make a window visible
  3662.  
  3663.    SYNOPSIS
  3664.  
  3665.         LT_ShowWindow(Handle,Activate);
  3666.                         A0      A1
  3667.  
  3668.         VOID LT_ShowWindow(LayoutHandle *,BOOL);
  3669.  
  3670.    FUNCTION
  3671.  
  3672.         The window attached to a LayoutHandle is made visible, this
  3673.         involves bringing it to the front, bringing the screen to
  3674.         the front the window resides on, unzooming the window and
  3675.         also moving the visible part of an autoscrolling screen.
  3676.  
  3677.    INPUTS
  3678.  
  3679.         Window - Pointer to Window structure.
  3680.  
  3681.         Activate - If TRUE the window will be activated as soon
  3682.             as it has been brought to the front.
  3683.  
  3684.         The arguments are passed in A0 and A1, this is *not* a
  3685.         typo.
  3686.  
  3687.    RESULT
  3688.  
  3689.         none
  3690.  
  3691.    BUGS
  3692.  
  3693.         In revisions earlier than v21 this routine consistently
  3694.         failed to reliably unzip a window in zoomed state. This
  3695.         could cause the calling application to wait for about
  3696.         five seconds before continuing execution.
  3697. gtlayout.library/LT_String2Fixed              gtlayout.library/LT_String2Fixed
  3698.  
  3699.    NAME
  3700.  
  3701.         LT_String2Fixed -- Convert an ASCII string into a fixed-point numeric
  3702.                            value.
  3703.  
  3704.    SYNOPSIS
  3705.  
  3706.         Fixed = LT_String2Fixed(String)
  3707.           D0                      A0
  3708.  
  3709.         FIXED LT_String2Fixed(STRPTR);
  3710.  
  3711.    FUNCTION
  3712.  
  3713.         This routine complements LT_Fixed2String, it implements a
  3714.         service similar to atof() in converting an ASCII string
  3715.         into a fixed-point number.
  3716.  
  3717.    INPUTS
  3718.  
  3719.         String - Pointer to null-terminated string.
  3720.  
  3721.    RESULT
  3722.  
  3723.         Fixed - Fixed-point number; will be 0.0 if non-numeric
  3724.                 characters are found in the input string.
  3725.  
  3726.    NOTES
  3727.  
  3728.         The decimal point to look for will be taken from the
  3729.         current locale settings. If locale.library is not
  3730.         installed, the `.' character will be used instead.
  3731. gtlayout.library/LT_UnlockWindow              gtlayout.library/LT_UnlockWindow
  3732.  
  3733.    NAME
  3734.  
  3735.         LT_UnlockWindow -- The complement to LT_LockWindow().
  3736.  
  3737.    SYNOPSIS
  3738.  
  3739.         LT_UnlockWindow(Window);
  3740.                           A0
  3741.  
  3742.         VOID LT_UnlockWindow(struct Window *);
  3743.  
  3744.    FUNCTION
  3745.  
  3746.         This routine unlocks a window locked using LT_LockWindow, freeing
  3747.         allocated memory, restoring the window characteristics to their
  3748.         original values.
  3749.  
  3750.    INPUTS
  3751.  
  3752.         Window - Pointer to window structure.
  3753.  
  3754.    RESULT
  3755.  
  3756.         none
  3757. gtlayout.library/LT_UpdateStrings       gtlayout.library/LT_UpdateStrings
  3758.  
  3759.    NAME
  3760.  
  3761.         LT_UpdateStrings -- Make sure all visible string buffer contents
  3762.                             get written into storage.
  3763.  
  3764.                             (requires gtlayout.library v9 or higher)
  3765.  
  3766.    SYNOPSIS
  3767.  
  3768.         LT_UpdateStrings(LayoutHandle);
  3769.                                 A0
  3770.  
  3771.         VOID LT_UpdateStrings(struct LayoutHandle *);
  3772.  
  3773.    FUNCTION
  3774.  
  3775.         The user can terminate input into a string gadget or an object
  3776.         derived from a string gadget by various means. They all have
  3777.         in common that the application receives no notification that
  3778.         the string gadget contents have changed. This is particularly
  3779.         nasty with objects which make use of LA_STRPTR or other
  3780.         tags. Using LT_UpdateStrings() you can force all visible string
  3781.         gadget objects to hand over their contents to the internal
  3782.         buffers. Do this before you eventually exit your input loop.
  3783.  
  3784.    INPUTS
  3785.  
  3786.         LayoutHandle - Pointer to LayoutHandle structure.
  3787.  
  3788.    RESULT
  3789.  
  3790.         none
  3791.